blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 7 410 | content_id stringlengths 40 40 | detected_licenses listlengths 0 51 | license_type stringclasses 2
values | repo_name stringlengths 5 132 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 80 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 5.85k 684M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 132
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 9.45M | extension stringclasses 28
values | content stringlengths 3 9.45M | authors listlengths 1 1 | author_id stringlengths 0 352 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
59a549c661e3b02161fdf475e333d5018b89eaba | 6635387159b685ab34f9c927b878734bd6040e7e | /src/com/brightcove/player/captioning/BrightcoveClosedCaptioningOptionsDialog$TextSizeChangedListener.java | c215a47f33e7a50fcaa48489bb3ae11a5fd13e31 | [] | no_license | RepoForks/com.snapchat.android | 987dd3d4a72c2f43bc52f5dea9d55bfb190966e2 | 6e28a32ad495cf14f87e512dd0be700f5186b4c6 | refs/heads/master | 2021-05-05T10:36:16.396377 | 2015-07-16T16:46:26 | 2015-07-16T16:46:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,834 | java | package com.brightcove.player.captioning;
import android.widget.RadioGroup;
import android.widget.RadioGroup.OnCheckedChangeListener;
import com.brightcove.player.R.id;
public class BrightcoveClosedCaptioningOptionsDialog$TextSizeChangedListener
implements RadioGroup.OnCheckedChangeListener
{
protected BrightcoveClosedCaptioningOptionsDialog$TextSizeChangedListener(BrightcoveClosedCaptioningOptionsDialog paramBrightcoveClosedCaptioningOptionsDialog) {}
private float getTextSize(int paramInt)
{
float f2 = 1.0F;
float f1;
if (paramInt == R.id.closed_captioning_options_text_size_50_percent) {
f1 = 0.5F;
}
for (;;)
{
String.format("sizeMultipler is %f", new Object[] { Float.valueOf(f1) });
return f1 * 14.0F;
if (paramInt == R.id.closed_captioning_options_text_size_75_percent)
{
f1 = 0.75F;
}
else
{
f1 = f2;
if (paramInt != R.id.closed_captioning_options_text_size_100_percent) {
if (paramInt == R.id.closed_captioning_options_text_size_150_percent)
{
f1 = 1.5F;
}
else
{
f1 = f2;
if (paramInt == R.id.closed_captioning_options_text_size_200_percent) {
f1 = 2.0F;
}
}
}
}
}
}
public void onCheckedChanged(RadioGroup paramRadioGroup, int paramInt)
{
String.format("Text Size %d selected", new Object[] { Integer.valueOf(paramInt) });
BrightcoveClosedCaptioningOptionsDialog.access$200(this$0).setTextSize(getTextSize(paramInt));
this$0.updateCaptions();
}
}
/* Location:
* Qualified Name: com.brightcove.player.captioning.BrightcoveClosedCaptioningOptionsDialog.TextSizeChangedListener
* Java Class Version: 6 (50.0)
* JD-Core Version: 0.7.1
*/ | [
"reverseengineeringer@hackeradmin.com"
] | reverseengineeringer@hackeradmin.com |
5cd34482f7cdda542aa963a410d8e70cb42449e3 | 42293f65c493451f80bce005405eeb81914193e1 | /TraderJournal/src/traderjournal/Activator.java | dba96f98d4df55f87661cd96e6b2a02882996568 | [] | no_license | phonguz/traderjournal | 037dd80bbac7c17709668732e4493dc6e6067a73 | c4d9f62e23a2861a6929ac9c93c20691ca194a51 | refs/heads/master | 2021-01-13T12:55:09.780369 | 2009-01-29T21:12:50 | 2009-01-29T21:12:50 | 32,339,308 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,395 | java | package traderjournal;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;
/**
* The activator class controls the plug-in life cycle
*/
public class Activator extends AbstractUIPlugin {
// The plug-in ID
public static final String PLUGIN_ID = "TraderJournal";
// The shared instance
private static Activator plugin;
/**
* The constructor
*/
public Activator() {
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
*/
public void stop(BundleContext context) throws Exception {
plugin = null;
super.stop(context);
}
/**
* Returns the shared instance
*
* @return the shared instance
*/
public static Activator getDefault() {
return plugin;
}
/**
* Returns an image descriptor for the image file at the given
* plug-in relative path
*
* @param path the path
* @return the image descriptor
*/
public static ImageDescriptor getImageDescriptor(String path) {
return imageDescriptorFromPlugin(PLUGIN_ID, path);
}
}
| [
"Tinus.Rautenbach@32bcd18d-314d-0410-a3ae-15b2b6a54095"
] | Tinus.Rautenbach@32bcd18d-314d-0410-a3ae-15b2b6a54095 |
a1e118b99f66025ae921085345812e21bfd2ab62 | c8fc5e4bcfd55eade186ef719e639a219c77cea2 | /Stack_Tester.java | 8527a53c072bd7674389463abf4b0a8366f05ccc | [] | no_license | brandontarney/DS_Lab1 | 7f9151cae7a57732c1bb47fb1ac70b25ef21db82 | 9444a7c1eada0a6c001ceac4d3b43ebf2d5362f8 | refs/heads/master | 2021-06-01T02:14:46.801775 | 2015-06-28T15:26:15 | 2015-06-28T15:26:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 917 | java | /**
*Test class for any stack
*
* @author Brandon Tarney
* @version 1.0 06/15/15
*/
public class Stack_Tester
{
public static void test()
{//Linked-list based stack
Stack_LL_CHAR test_Stack = new Stack_LL_CHAR();
System.out.println("\nThese print statements are for the array-based stack");
System.out.println(test_Stack.get_Size());
if (test_Stack.is_Empty()) System.out.println("The Stack is empty ");//expect stack is empty
test_Stack.push('I');
test_Stack.push('O');
test_Stack.push('U');
if (test_Stack.is_Empty()) System.out.println("The Stack is empty ");//expect stack NOT empty
System.out.println("The stack has this many items on it: " + test_Stack.get_Size());
test_Stack.emptyStack();
System.out.println("The stack has this many items on it: " + test_Stack.get_Size());
}
}//end stack tester | [
"brandon.tarney@gmail.com"
] | brandon.tarney@gmail.com |
499c1b2483881eb96e903212e40c05f7d3dc8597 | f5bcc1243ffbc9b69b0513325da8e995363fa308 | /xgov/src/main/java/cn/com/yeexun/standardAudit/entity/AuditDetail.java | 44bb4e005a2cd83e8809a5542efd598bf87f1c45 | [] | no_license | yindongjun/yx-xgov | 7a9772c11b2d3f68e8e88dc6d7666563154bddfd | f1d81a9185cde9cc48a2aadcaf89f35428c89400 | refs/heads/master | 2023-02-19T12:55:15.082484 | 2019-09-20T01:45:57 | 2019-09-20T01:45:57 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,088 | java | package cn.com.yeexun.standardAudit.entity;
import java.util.Date;
import javax.persistence.Table;
import cn.com.common.ssm.engine.bean.Unique;
@Table(name = "tb_standard_audit_detail")
public class AuditDetail extends Unique {
private String auditor;
private Date auditTime;
private String auditResult;
private String auditDesc;
private long standardAuditId;
public String getAuditor() {
return auditor;
}
public void setAuditor(String auditor) {
this.auditor = auditor;
}
public Date getAuditTime() {
return auditTime;
}
public void setAuditTime(Date auditTime) {
this.auditTime = auditTime;
}
public String getAuditResult() {
return auditResult;
}
public void setAuditResult(String auditResult) {
this.auditResult = auditResult;
}
public String getAuditDesc() {
return auditDesc;
}
public void setAuditDesc(String auditDesc) {
this.auditDesc = auditDesc;
}
public long getStandardAuditId() {
return standardAuditId;
}
public void setStandardAuditId(long standardAuditId) {
this.standardAuditId = standardAuditId;
}
}
| [
"jin.huo@sihuatech.com"
] | jin.huo@sihuatech.com |
2c063563cbf5b710a249fa1976aac83cb9bda0d6 | ae99d18cf1dd767a881e90133ed348fa861194d4 | /user/server/src/main/java/com/cq/enums/ResultEnum.java | 75f9c2d281fbb68f470c8faa0d212ee70c620d42 | [] | no_license | wiskeycq/springCloud_learning2.0 | edc2968f4c986e0270ed2ad0687590abe3307386 | 408a51a6e42207af8af6cc6751072a353bf30a7c | refs/heads/master | 2020-03-21T08:58:59.345908 | 2018-07-10T08:55:15 | 2018-07-10T08:55:15 | 138,377,215 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 403 | java | package com.cq.enums;
import lombok.Getter;
/**
* @Auther: caoqsq
* @Date: 2018/6/28 17:16
* @Description:
*/
@Getter
public enum ResultEnum {
LOGIN_FAIL(1, "登录失败"),
ROLE_ERROR(2, "角色权限有误"),
;
private Integer code;
private String message;
ResultEnum(Integer code, String message) {
this.code = code;
this.message = message;
}
}
| [
"1213284874@qq.com"
] | 1213284874@qq.com |
cb2799d6733e4f3d478c872e36980518651f84e2 | a56c966615252d1c2d739836bf44caafe66f387f | /src/main/java/de/st_ddt/crazyutil/databases/FlatDatabaseEntry.java | 61ca7220056f1b98db3efde2cc08917b8d6fdb1f | [
"Apache-2.0"
] | permissive | ST-DDT/CrazyCore | eada1ad23d1c733afd022912e7b970d3df2e813d | f6f33dd0826c6fd5d066db94dbdacbfe3b96e842 | refs/heads/master | 2022-06-27T11:02:17.850223 | 2022-06-21T08:13:35 | 2022-06-21T08:13:35 | 15,260,398 | 0 | 10 | Apache-2.0 | 2022-06-21T08:13:37 | 2013-12-17T16:56:14 | Java | UTF-8 | Java | false | false | 189 | java | package de.st_ddt.crazyutil.databases;
public interface FlatDatabaseEntry extends DatabaseEntry
{
// public FlatDatabaseEntry(String[] rawData);
public String[] saveToFlatDatabase();
}
| [
"ST-DDT@gmx.de"
] | ST-DDT@gmx.de |
f5b9b31dd6cb44a8892636f638febf2ace27abe9 | 3f2c9b7ed1a56da6dbe0110ebcdbd088052ef5b6 | /test-market-android/src/test/java/com/market/uitest/myTest/MyTest.java | 6a2195d2797a9391155f64378b051b027dc9f44d | [] | no_license | testyougong/test-market-android | 530d11a866aa3269cec5d3358b14c17c8946767f | a999590603d961a8bb9e8002774bb8a179f833ff | refs/heads/master | 2020-05-25T00:42:13.396752 | 2017-05-12T08:38:37 | 2017-05-12T08:38:37 | 84,893,998 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,029 | java | package com.market.uitest.myTest;
import com.market.base.Base;
import com.market.base.Constant;
import com.market.pages.myPages.MyPage;
import com.market.pages.myPages.MyCase;
import com.market.pages.myPages.MyPageTest;
import com.market.pages.myPages.UserCase;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* Created by zhouxin on 17/4/25.
*/
public class MyTest extends Base{
@BeforeClass
public void setUp() throws Exception{
prepareAndroidForAppium();
}
@AfterClass
public void tearDown() throws Exception {
driver.quit();
}
@Test
public static void testMy() throws Exception {
//初始化
MyPageTest myPageTest = new MyPageTest();
MyPage my = new MyCase();
MyPage user = new UserCase(Constant.phone);
//测试我的页面tagName
myPageTest.getTagName(my);
//测试我的页面用户tabName
myPageTest.getTabName(user);
}
}
| [
"zhouxin@lsh123.com"
] | zhouxin@lsh123.com |
9029d847648f90f2d55b257cc3aea16cca5246b8 | 172e86c2091e3a8c0c11aa47aa71705ae2bdb86e | /flutter_app/security_control/android/app/src/main/java/com/oamkprojects/security_control/ServerSyncWorker.java | ba7ace6d7882d5145b7f30e51174410f3c45fb16 | [] | no_license | OAMK-Product-Design-and-Implementation/Project_2020 | dcdd38605c6659f75bc671edea718215ad0d5e1e | 04da5b72e7e04319eed6405ed62daa1c0f2b0ffe | refs/heads/main | 2023-02-02T05:10:42.787080 | 2020-12-18T16:32:12 | 2020-12-18T16:32:12 | 309,186,719 | 0 | 1 | null | 2020-12-18T16:32:13 | 2020-11-01T20:55:46 | Dart | UTF-8 | Java | false | false | 8,804 | java | package com.oamkprojects.security_control;
import android.app.PendingIntent;
import android.app.admin.DnsEvent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.webkit.HttpAuthHandler;
import androidx.annotation.NonNull;
import androidx.core.app.NotificationCompat;
import androidx.core.app.NotificationManagerCompat;
import androidx.work.Worker;
import androidx.work.WorkerParameters;
//import com.google.common.util.concurrent.Listenable
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import org.json.JSONArray;
import org.json.JSONException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Random;
import io.flutter.Log;
public class ServerSyncWorker extends Worker {
private static final String CHANNEL_ID = "securitycontrolintruderalerts";
private final String DEBUG_TAG = this.getClass().getSimpleName();
private String updateIntervalKey = "flutter.updateinterval";
private String serverAddressKey = "flutter.serveraddress";
private String gopigokey = "flutter.gopigoexample";
// private ArrayList msgList;
public ServerSyncWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
super(context, workerParams);
}
@NonNull
@Override
public Result doWork() {
Context applicationContext = getApplicationContext();
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(applicationContext);
SharedPreferences prefs = applicationContext.getSharedPreferences("FlutterSharedPreferences",
Context.MODE_PRIVATE);
int battery;
String serverAddress;
serverAddress = prefs.getString(serverAddressKey, "195.148.21.106");
Log.d(DEBUG_TAG, "Got server addr. from prefs:" + serverAddress);
Random random = new Random();
String url = "http://" + serverAddress + "/api/devices/get/activemessages";
String getResponse;
try {
getResponse = downloadContent(url);
} catch (IOException e) {
Log.d(DEBUG_TAG, "Unable to retrieve data: " + e.toString());
// Send notification?
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(applicationContext, CHANNEL_ID)
.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle("Could not sync with server")
.setContentText("Make sure server address is correct")
.setPriority(NotificationCompat.PRIORITY_HIGH);
PendingIntent contentIntent = PendingIntent.getActivity(applicationContext, 0,
new Intent(applicationContext, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder.setContentIntent(contentIntent);
notificationManager.notify(123, mBuilder.build());
return Result.retry();
}
Log.d(DEBUG_TAG, "Response is: " + getResponse);
ArrayList msgList = jsonToMessageList(getResponse.toString());
boolean resultComplete = volleyComplete(msgList);
if(resultComplete == true){
return Result.success();
}
else{
return Result.retry();
}
}
private String downloadContent(String myurl) throws IOException {
InputStream is = null;
int length = 500;
try {
URL url = new URL(myurl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(10000 /* milliseconds */);
conn.setConnectTimeout(15000 /* milliseconds */);
conn.setRequestMethod("GET");
conn.setDoInput(true);
conn.connect();
int response = conn.getResponseCode();
Log.d(DEBUG_TAG, "The response is: " + response);
is = conn.getInputStream();
// Convert the InputStream into a string
String contentAsString = convertInputStreamToString(is, length);
return contentAsString;
} finally {
if (is != null) {
is.close();
}
}
}
public String convertInputStreamToString(InputStream stream, int length) throws IOException, UnsupportedEncodingException {
Reader reader = null;
reader = new InputStreamReader(stream, "UTF-8");
char[] buffer = new char[length];
reader.read(buffer);
return new String(buffer);
}
ArrayList jsonToMessageList(String msg){
JSONArray jsonArray = new JSONArray();
ArrayList msgArray = new ArrayList();
try {
jsonArray = new JSONArray(msg);
} catch (JSONException e) {
e.printStackTrace();
}
if (jsonArray != null) {
for (int i = 0; i < jsonArray.length(); i++) {
try {
msgArray.add(jsonArray.getString(i));
} catch (JSONException e) {
e.printStackTrace();
}
}
}
return msgArray;
}
boolean volleyComplete(ArrayList msgList) {
boolean sendNotification = false;
boolean intruderAlert = false;
Context applicationContext = getApplicationContext();
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(applicationContext);
ArrayList oneMessageList = new ArrayList();
ArrayList criticalActions = new ArrayList(); // Stores only errors
ArrayList intruderAlerts = new ArrayList(); // Stores only intruders
String notificationContent = "";
String notificationSubContent = "";
if (msgList != null) {
//Log.d(DEBUG_TAG, msgList.get(0).getClass().toString());
for(int i = 0; i < msgList.size(); i++){
oneMessageList = jsonToMessageList(msgList.get(i).toString());
// Info messages will not trigger notification:
if(oneMessageList.get(1).equals("Error")){
sendNotification = true;
criticalActions.add(oneMessageList);
}
else if(oneMessageList.get(1).equals("Intruder")){
sendNotification = true;
intruderAlerts.add(oneMessageList);
intruderAlert = true;
}
}
if(criticalActions.size() == 1){
oneMessageList = (ArrayList) criticalActions.get(0);
notificationContent = "Action required: " + oneMessageList.get(4).toString(); // deviceName
notificationSubContent = oneMessageList.get(2).toString(); // Explanation
}
else if(criticalActions.size() > 1){
notificationContent = Integer.toString(criticalActions.size()) + " actions required";
notificationSubContent = "Tap to open Security Control";
}
if(intruderAlerts.size() > 0){
notificationContent = "INTRUDER ALERT";
if (intruderAlerts.size() == 1){
oneMessageList = (ArrayList) intruderAlerts.get(0);
notificationSubContent = oneMessageList.get(2).toString();
}
else {
notificationSubContent = Integer.toString(intruderAlerts.size()) + " intruder alerts";
}
}
if(sendNotification == true){
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(applicationContext, CHANNEL_ID)
.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle(notificationContent)
.setContentText(notificationSubContent)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setAutoCancel(true)
.setOnlyAlertOnce(false);
PendingIntent contentIntent = PendingIntent.getActivity(applicationContext, 0,
new Intent(applicationContext, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder.setContentIntent(contentIntent);
notificationManager.notify(1234, mBuilder.build());
}
}
return true;
}
} | [
"jaakko.ropponen98@gmail.com"
] | jaakko.ropponen98@gmail.com |
c64b4075ee4668ed322d658be089af6a828067d4 | 9ab91b074703bcfe9c9407e1123e2b551784a680 | /plugins/org.eclipse.osee.orcs.core/src/org/eclipse/osee/orcs/core/internal/console/PerformanceInfoCommand.java | 2e4f5a9707c36f7c08454efb07690de1fd3dcade | [] | no_license | pkdevbox/osee | 7ad9c083c3df8a7e9ef6185a419680cc08e21769 | 7e31f80f43d6d0b661af521fdd93b139cb694001 | refs/heads/master | 2021-01-22T00:30:05.686402 | 2015-06-08T21:19:57 | 2015-06-09T18:42:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,964 | java | /*******************************************************************************
* Copyright (c) 2012 Boeing.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Boeing - initial API and implementation
*******************************************************************************/
package org.eclipse.osee.orcs.core.internal.console;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.concurrent.Callable;
import org.eclipse.osee.console.admin.Console;
import org.eclipse.osee.console.admin.ConsoleCommand;
import org.eclipse.osee.console.admin.ConsoleParameters;
import org.eclipse.osee.executor.admin.CancellableCallable;
import org.eclipse.osee.orcs.OrcsApi;
import org.eclipse.osee.orcs.OrcsPerformance;
import org.eclipse.osee.orcs.statistics.IndexerStatistics;
import org.eclipse.osee.orcs.statistics.QueryStatistics;
/**
* @author Roberto E. Escobar
*/
public class PerformanceInfoCommand implements ConsoleCommand {
private OrcsApi orcsApi;
private enum StatsType {
QUERY,
INDEXER,
ALL
}
public void setOrcsApi(OrcsApi orcsApi) {
this.orcsApi = orcsApi;
}
public OrcsApi getOrcsApi() {
return orcsApi;
}
@Override
public String getName() {
return "performance";
}
@Override
public String getDescription() {
return "Displays performance information";
}
@Override
public String getUsage() {
return "[statusId=<[QUERY|INDEXER|ALL],..>] [reset=<TRUE|FALSE>]";
}
private Collection<StatsType> toStatusTypes(String[] stats) {
Collection<StatsType> statsType = new HashSet<StatsType>();
boolean addAllStatTypes = false;
if (stats != null && stats.length > 0) {
for (String stat : stats) {
StatsType type = StatsType.valueOf(stat.toUpperCase());
if (StatsType.ALL == type) {
addAllStatTypes = true;
break;
} else {
statsType.add(type);
}
}
} else {
addAllStatTypes = true;
}
if (addAllStatTypes) {
statsType.addAll(Arrays.asList(StatsType.values()));
}
return statsType;
}
@Override
public Callable<?> createCallable(Console console, ConsoleParameters params) {
boolean isResetAllowed = params.getBoolean("reset");
Collection<StatsType> statsType = toStatusTypes(params.getArray("statusId"));
OrcsPerformance performance = getOrcsApi().getOrcsPerformance(null);
return new PerformanceCallable(console, performance, statsType, isResetAllowed);
}
private static final class PerformanceCallable extends CancellableCallable<Boolean> {
private final Console console;
private final OrcsPerformance performance;
private final Collection<StatsType> statsType;
private final boolean isResetAllowed;
public PerformanceCallable(Console console, OrcsPerformance performance, Collection<StatsType> statsType, boolean isResetAllowed) {
super();
this.console = console;
this.performance = performance;
this.statsType = statsType;
this.isResetAllowed = isResetAllowed;
}
private boolean isResetAllowed(StatsType type) {
return isResetAllowed && isWriteAllowed(type);
}
private boolean isWriteAllowed(StatsType type) {
return statsType.contains(type);
}
@Override
public Boolean call() throws Exception {
if (isResetAllowed(StatsType.QUERY)) {
performance.clearQueryStatistics();
}
if (isWriteAllowed(StatsType.QUERY)) {
QueryStatistics queryStats = performance.getQueryStatistics();
writeStatistics(queryStats);
}
if (isResetAllowed(StatsType.INDEXER)) {
performance.clearIndexerStatistics();
}
if (isWriteAllowed(StatsType.INDEXER)) {
IndexerStatistics indexerStats = performance.getIndexerStatistics();
IndexerUtil.writeStatistics(console, indexerStats);
}
return Boolean.TRUE;
}
private void writeStatistics(QueryStatistics stats) {
console.writeln("\n----------------------------------------------");
console.writeln(" Search Stats");
console.writeln("----------------------------------------------");
console.writeln("Total Searches - [%d]", stats.getTotalSearches());
console.writeln("Search Time - avg: [%s] ms - longest: [%s] ms", stats.getAverageSearchTime(),
stats.getLongestSearchTime());
console.writeln("Longest Search - %s", stats.getLongestSearch());
}
}
}
| [
"ryan.d.brooks@boeing.com"
] | ryan.d.brooks@boeing.com |
d8f6adc9601b638ba9daa670eafe6836b0ec3115 | 5622d518bac15a05590055a147628a728ca19b23 | /jcore-mallet-0.4/src/main/java/edu/umass/cs/mallet/base/pipe/tsf/tests/TestSequencePrintingPipe.java | 7665e878bfc8872b2600967ea33a433da3396535 | [
"BSD-2-Clause",
"CPL-1.0"
] | permissive | JULIELab/jcore-dependencies | e51349ccf6f26c7b7dab777a9e6baacd7068b853 | a303c6a067add1f4b05c4d2fe31c1d81ecaa7073 | refs/heads/master | 2023-03-19T20:26:55.083193 | 2023-03-09T20:32:13 | 2023-03-09T20:32:13 | 44,806,492 | 4 | 2 | BSD-2-Clause | 2022-11-16T19:48:08 | 2015-10-23T10:32:10 | Java | UTF-8 | Java | false | false | 3,328 | java | /* Copyright (C) 2003 Univ. of Massachusetts Amherst, Computer Science Dept.
This file is part of "MALLET" (MAchine Learning for LanguagE Toolkit).
http://www.cs.umass.edu/~mccallum/mallet
This software is provided under the terms of the Common Public License,
version 1.0, as published by http://www.opensource.org. For further
information, see the file `LICENSE' included with this distribution. */
package edu.umass.cs.mallet.base.pipe.tsf.tests;
import edu.umass.cs.mallet.base.pipe.Pipe;
import edu.umass.cs.mallet.base.pipe.tsf.SequencePrintingPipe;
import edu.umass.cs.mallet.base.types.*;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import java.io.PrintWriter;
import java.io.StringWriter;
/**
* Created: Jul 8, 2005
*
* @author <A HREF="mailto:casutton@cs.umass.edu>casutton@cs.umass.edu</A>
* @version $Id: TestSequencePrintingPipe.java,v 1.2 2005/07/08 20:37:32 casutton Exp $
*/
public class TestSequencePrintingPipe extends TestCase {
public TestSequencePrintingPipe (String name)
{
super (name);
}
public static Test suite ()
{
return new TestSuite (TestSequencePrintingPipe.class);
}
public static void testPrinting ()
{
Alphabet dict = dictOfSize (3);
FeatureVector[] vecs = new FeatureVector[] {
new FeatureVector (dict, new int[] { 0, 1 }),
new FeatureVector (dict, new int[] { 0, 2 }),
new FeatureVector (dict, new int[] { 2 }),
new FeatureVector (dict, new int[] { 1, 2 }),
};
LabelAlphabet ld = labelDictOfSize (3);
LabelSequence lbls = new LabelSequence (ld, new int [] { 0, 2, 0, 1});
FeatureVectorSequence fvs = new FeatureVectorSequence (vecs);
StringWriter sw = new StringWriter ();
PrintWriter w = new PrintWriter (sw);
Pipe p = new SequencePrintingPipe (w);
// pipe the instance
new Instance (fvs, lbls, null, null, p);
// Do a second one
FeatureVectorSequence fvs2 = new FeatureVectorSequence (new FeatureVector[] {
new FeatureVector (dict, new int[] { 1 }),
new FeatureVector (dict, new int[] { 0 }),
});
LabelSequence lbls2 = new LabelSequence (ld, new int[] { 2, 1 });
new Instance (fvs2, lbls2, null, null, p);
w.close();
assertEquals ("LABEL0 feature0 feature1\n" +
"LABEL2 feature0 feature2\n" +
"LABEL0 feature2\n" +
"LABEL1 feature1 feature2\n" +
"\n" +
"LABEL2 feature1\n" +
"LABEL1 feature0\n\n",
sw.toString());
}
private static Alphabet dictOfSize (int n)
{
Alphabet dict = new Alphabet ();
for (int i = 0; i < n; i++) {
dict.lookupIndex ("feature"+i);
}
return dict;
}
private static LabelAlphabet labelDictOfSize (int n)
{
LabelAlphabet dict = new LabelAlphabet ();
for (int i = 0; i < n; i++) {
dict.lookupIndex ("LABEL"+i);
}
return dict;
}
public static void main (String[] args) throws Throwable
{
TestSuite theSuite;
if (args.length > 0) {
theSuite = new TestSuite ();
for (int i = 0; i < args.length; i++) {
theSuite.addTest (new TestSequencePrintingPipe (args[i]));
}
} else {
theSuite = (TestSuite) suite ();
}
junit.textui.TestRunner.run (theSuite);
}
}
| [
"chew@gmx.net"
] | chew@gmx.net |
cabb49698030ceebb37e53bd98053482c3d03255 | 411b4087e6fb55f8383e9d1e481efc7afc3316a5 | /base/Random.java | 94edcc44e7a03f73f833d50c08730cb67c45433f | [] | no_license | wang-404/JavaStudy | 6c73f0d67e6a4cfe87d911ed15da938a19e5a506 | 0ef4e3fa58b244fc9c4dbd48dc21a945568480ca | refs/heads/main | 2023-05-30T21:48:44.161973 | 2021-06-15T10:43:11 | 2021-06-15T10:43:11 | 368,430,747 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 331 | java | package baseStudy;
public class Random {
public static void main(String[] args) {
//获取10到90的随机数
double valu = Math.random()*90 + 10;//[0.0,1.0)-->[0.0,90.0)-->[10.0-->100.0)
int value = (int)valu;//[10.0-->100.0)-->[10,99)
System.out.println(value);
//公式：[a,b]:(int)(Math.random()*(b-a+1)+a)
}
}
| [
"1450479286@qq.com"
] | 1450479286@qq.com |
4946bfb0da51ee9e902b57b2ae326c0b6a1b6c0d | e1bbb1ea4ce1c2983010d806568c1c5ba3b37f36 | /src/main/java/com/hglee/batch/config/LoggingTaskDecorator.java | 20f3f74b79153ae3938f33f34ab323cb928a359b | [] | no_license | coderhglee/spring-batch-scheduler | 47a58ab1595b4eaf05539462fd156a75e79d3f55 | f0b16bd9fd8d37b28acda30c83d8bd9ad54c3b86 | refs/heads/master | 2022-12-23T11:33:05.877879 | 2019-10-13T10:48:10 | 2019-10-13T11:25:06 | 207,481,337 | 0 | 0 | null | 2022-12-10T05:32:32 | 2019-09-10T06:26:37 | Java | UTF-8 | Java | false | false | 565 | java | package com.hglee.batch.config;
import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;
import java.util.Map;
public class LoggingTaskDecorator implements TaskDecorator {
@Override
public Runnable decorate(Runnable task) {
Map<String, String> callerThreadContext = MDC.getCopyOfContextMap();
return () -> {
if (callerThreadContext == null) {
MDC.clear();
} else {
MDC.setContextMap(callerThreadContext);
}
task.run();
};
}
}
| [
"goodna17@gmail.com"
] | goodna17@gmail.com |
69bdcd8e01043e290a18dbf4e0f1bfcadf9d9a82 | 4cfda4f1b4d7703e1b460359012082c158103476 | /miliconvert/xsmt/trunk/plugins/org.miliconvert.xsmt.functions/src/org/miliconvert/xsmt/functions/math/Division.java | fd26891ae3bfcf418c29462c25cd01b9e8997e59 | [] | no_license | opensourcejavadeveloper/military_xml_project_miliconvert | e62dee54499fdb8abaa76a9d44ed97ace19dc887 | bb0276970c243ec3acc07fd4b255673d6d7dd080 | refs/heads/master | 2022-01-10T18:11:39.021413 | 2018-08-20T12:45:02 | 2018-08-20T12:45:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,560 | java | /* ***** BEGIN LICENSE BLOCK *****
* Version: GPL 2.0
*
* The contents of this file are subject to the GNU General Public
* License Version 2 or later (the "GPL").
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Initial Developer of the Original Code is
* BT Global Services / Etat français Ministre de la Défense
*
* ***** END LICENSE BLOCK ***** */
package org.miliconvert.xsmt.functions.math;
import org.miliconvert.xsmt.tmodel.AbstractFunctionImpl;
import org.miliconvert.xsmt.tmodel.TModelException;
import org.miliconvert.xsmt.tmodel.Variable;
public class Division extends AbstractFunctionImpl {
public Division() {
super();
variables.add(new Variable("a")); //$NON-NLS-1$
variables.add(new Variable("b")); //$NON-NLS-1$
}
public String getName() {
return Messages.Division_label_name;
}
/**
* Divide a and b
*
* @param a
* @param b
* @return the division of a and b
* @throws TModelException
* when one of the parameters is null
*/
public String execute(String a, String b) throws TModelException {
if (a == null || b == null) {
throw new TModelException(
"One parameter of the addition function is null: " + ": a=" //$NON-NLS-1$ //$NON-NLS-2$
+ a + ", " + "b=" + b); //$NON-NLS-1$ //$NON-NLS-2$
} else
return "" + (Float.parseFloat(a) / Float.parseFloat(b));
}
}
| [
"you@example.com"
] | you@example.com |
cf02cbb3fd0e5c285b642854b2e67d9172694f17 | b5383bee167f74a92a24e56b4116a1fcea71aae4 | /lifedefender-service/src/main/java/com/lifeshs/service1/data/impl/HobbyServiceImpl.java | ee8ca6df783404baf5c713343bfdd8585c8b8cc4 | [] | no_license | sengeiou/The-life-guard | 5fa083f5dcde9d330232dee6d96c4a232b54072a | 0984ceb809ccf3a79be22df9ed270a3d6ca86687 | refs/heads/master | 2020-06-04T15:48:41.864745 | 2019-03-07T15:15:33 | 2019-03-07T15:15:33 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,496 | java | package com.lifeshs.service1.data.impl;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.lifeshs.dao1.data.HobbyDao;
import com.lifeshs.dao1.data.HotHobbyDao;
import com.lifeshs.po.data.HobbyPO;
import com.lifeshs.service1.data.HobbyService;
import com.lifeshs.utils.ListUtil;
import com.lifeshs.vo.data.hobby.HotHobbyVO;
@Service(value = "hobbyService")
public class HobbyServiceImpl implements HobbyService {
@Resource(name = "hobbyDao")
private HobbyDao hobbyDao;
@Resource(name = "hotHobbyDao")
private HotHobbyDao hotHobbyDao;
@Override
public HobbyPO getHobby(int id) {
return hobbyDao.getHobby(id);
}
@Override
public List<HobbyPO> listHobby() {
return hobbyDao.findHobbyList();
}
@Override
public List<HobbyPO> listHobby(List<Integer> idList) {
// 移除重复的id
idList = ListUtil.removeRepeatElement(idList, Integer.class);
return hobbyDao.findHobbyByIdList(idList);
}
@Override
public List<HotHobbyVO> listHotHobby(int maxSize) {
List<HotHobbyVO> dataList = new ArrayList<>();
if (maxSize == 0) {
return dataList;
}
return hotHobbyDao.findHotHobbyList(maxSize);
}
@Override
public List<HobbyPO> listModifyHobby(Date datePoint) {
return hobbyDao.findModifyHobbyList(datePoint);
}
}
| [
"877734642@qq.com"
] | 877734642@qq.com |
3082a42725ef7415ad97ea25bca286981b56ec57 | 8220269130d9bc9d863d188938b9aa95d26ad46b | /proj3/ViewListener.java | 8ebb7c3ea2d7fe30df65e94dd14d019e3a1eff25 | [] | no_license | jahoffgir/251 | 8702e37fa746f048f4b855d70eef3c8fa7e52e2d | abf365f273cac3b11370fbfab2a34a1b516b8a74 | refs/heads/master | 2021-03-19T06:02:55.291233 | 2018-05-01T14:37:17 | 2018-05-01T14:37:17 | 119,757,379 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 977 | java | /**
* Interface ViewListener specifies the interface for an object that receives
* reports from the View in the SixQueen Game.
*
* @author Alan Kaminsky
* @author Jahongir Amirkulov
* @version 04/05/18
*/
public interface ViewListener {
// Exported operations.
/**
* Report that a player joined the game.
*
* @param view View object making the report.
* @param name Player's name.
*/
public void join(ModelListener view, String name);
/**
* Report that a square was chosen.
*
* @param view View object making the report.
* @param i Square index.
* @param j Square index.
*/
public void squareChosen(ModelListener view, int i, int j);
/**
* Report that a new game was requested.
*
* @param view View object making the report.
*/
public void newGame(ModelListener view);
/**
* Report that the player quit.
*
* @param view View object making the report.
*/
public void quit(ModelListener view);
} | [
"amjahongir@gmail.com"
] | amjahongir@gmail.com |
e34730533975a220688fc661ba1ae2775506ba0e | 9c0a201fc2f9f0bc6e7facc1af432666718d7af3 | /src/main/java/com/RPC/Client/LoginController.java | f7ce8014bf6f5eab15f39b0173d8ed0d14b1bec8 | [] | no_license | cy122792387/hadooptest | 5ef43654d5d6070b2f804c7afe24121395524f6f | e424c9b4345bcea00536c4180cbc776141ba905b | refs/heads/master | 2021-01-01T18:39:46.785296 | 2017-08-06T01:23:51 | 2017-08-06T01:23:51 | 98,397,109 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 610 | java | package com.RPC.Client;
import com.RPC.protocol.LoginServiceInterface;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;
import java.io.IOException;
import java.net.InetSocketAddress;
public class LoginController {
public static void main(String[] args) throws IOException {
LoginServiceInterface proxy =
RPC.getProxy(LoginServiceInterface.class,
LoginServiceInterface.versionID,
new InetSocketAddress("127.0.0.1", 10000),
new Configuration());
String res = proxy.login("fengjie", "123");
System.out.println(res);
}
}
| [
"cy122792387@gmail.com"
] | cy122792387@gmail.com |
ed872f407a67a4c633d3049df2ce0ecbbac0ef7e | 674447519bab49c0316d6e76cf03be6ee14c0bd6 | /websocket/src/main/java/com/taobao/tail/samples/websocket/snake/Direction.java | 546813fd87bc934491cbd5a122bf41b283ebbda2 | [] | no_license | yingkuohao/springcloud-learn | 0dfd0d9f869f5261d132f36b27866dc825491069 | 5237eb96f132fd4e3de89e79a7efefc8d0256f03 | refs/heads/master | 2020-05-22T06:34:19.643322 | 2017-04-13T11:04:51 | 2017-04-13T11:04:51 | 64,824,791 | 2 | 2 | null | null | null | null | UTF-8 | Java | false | false | 914 | 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 com.taobao.tail.samples.websocket.snake;
public enum Direction {
NONE, NORTH, SOUTH, EAST, WEST
}
| [
"kuohao.ykh@alibaba-inc.com"
] | kuohao.ykh@alibaba-inc.com |
1bb6bbd4be7e793a6c45866f9bebb5096a50b8aa | 5346e62ede7f277b14f27cdf759d927b57a0eb09 | /src/org/firebears/commands/MoveDirectionTime.java | c9bae6ad92059619679cfc2038c76a343e42a001 | [] | no_license | firebears-frc/FB2014 | 70c99b2fdb0d1616163bb797dba18fc419542618 | 96bab4198f879471c4371cebee7949ce9ac4b9ae | refs/heads/master | 2021-01-12T21:28:16.794901 | 2014-12-03T03:02:34 | 2014-12-03T03:02:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,517 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package org.firebears.commands;
import edu.wpi.first.wpilibj.can.CANTimeoutException;
import edu.wpi.first.wpilibj.command.Command;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;
import java.lang.Math.*;
import org.firebears.Robot;
import org.firebears.RobotMap;
/**
*
* @author javad
*/
public class MoveDirectionTime extends Command {
double time;
int dir;
int tele;
public MoveDirectionTime(double getTime, int getDir, int getHooblob) {
// Use requires() here to declare subsystem dependencies
// eg. requires(chassis);
time = getTime;
dir = getDir;
tele = getHooblob;
}
// Called just before this Command runs the first time
protected void initialize() {
setTimeout(time);
}
// Called repeatedly when this Command is scheduled to run
protected void execute() {
try {
double current = RobotMap.chassisFrontRight.getOutputCurrent() + RobotMap.chassisRearLeft.getOutputCurrent() + RobotMap.chassisFrontLeft.getOutputCurrent() + RobotMap.chassisRearRight.getOutputCurrent();
double avg = current / 4;
double AbsoluteAvg = Math.abs(avg);
if (RobotMap.DEBUG) { SmartDashboard.putNumber("AverageCurrent", AbsoluteAvg); }
if (AbsoluteAvg >= 10){
end();
}
if (dir < 0.0) {
Robot.chassis.move(-0.3, 0.0);
}
if (dir > 0.0) {
Robot.chassis.move(0.3, 0.0);
}
}
catch (CANTimeoutException e) {
e.printStackTrace();
}
}
// Make this return true when this Command no longer needs to run execute()
protected boolean isFinished() {
if (Robot.chassis.getDistance() <= 20) {
return true;
}
if (tele == 1) {
return isTimedOut() || Robot.vacuum.isBallAttached();
} else if (tele != 1) {
return isTimedOut();
}
return isTimedOut();
}
// Called once after isFinished returns true
protected void end() {
Robot.chassis.move(0.0, 0.0);
}
// Called when another command which requires one or more of the same
// subsystems is scheduled to run
protected void interrupted() {
end();
}
}
| [
"KeithRieck@gmail.com"
] | KeithRieck@gmail.com |
f879f94dcdd24406e5c226bf409e646fdd6ebeaa | e5fdec9df80b4958f49250f90fd05c13e3bda8b7 | /org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui/src-gen/org/servicifi/gelato/language/cobol/preprocess/resource/preprocess/ui/PreprocessOutlinePage.java | a0589b132b66da84eac26b44dabee3d18aa2a574 | [] | no_license | amirms/gelato | 9125e6ac3a56e5bcfd032db855a4c269bdfc5152 | 972d7309dc37c57d17d2b1486a49f00830983eb8 | refs/heads/master | 2021-06-03T22:07:12.010077 | 2019-03-10T11:54:27 | 2019-03-10T11:54:27 | 27,443,539 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,599 | java | /**
* <copyright>
* </copyright>
*
*
*/
package org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui;
/**
* Simple Outline Page using the ReflectiveItemAdapters provided by EMF
*/
public class PreprocessOutlinePage extends org.eclipse.ui.part.Page implements org.eclipse.jface.viewers.ISelectionProvider, org.eclipse.jface.viewers.ISelectionChangedListener, org.eclipse.ui.views.contentoutline.IContentOutlinePage {
public final static String CONTEXT_MENU_ID = "org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.outlinecontext";
/**
* The auto expand level determines the depth to which the outline tree is
* expanded by default.
*/
public static int AUTO_EXPAND_LEVEL = 2;
/**
* The provider for the resource that is displayed in the outline page. Normally
* this is the current editor.
*/
private org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.IPreprocessResourceProvider resourceProvider;
private org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.PreprocessOutlinePageTreeViewer treeViewer;
private org.eclipse.core.runtime.ListenerList selectionChangedListeners = new org.eclipse.core.runtime.ListenerList();
public PreprocessOutlinePage(org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.IPreprocessResourceProvider resourceProvider) {
super();
this.resourceProvider = resourceProvider;
}
public void createControl(org.eclipse.swt.widgets.Composite parent) {
treeViewer = new org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.PreprocessOutlinePageTreeViewer(parent, org.eclipse.swt.SWT.MULTI | org.eclipse.swt.SWT.H_SCROLL | org.eclipse.swt.SWT.V_SCROLL);
Object[] listeners = selectionChangedListeners.getListeners();
for (int i = 0; i < listeners.length; ++i) {
org.eclipse.jface.viewers.ISelectionChangedListener l = (org.eclipse.jface.viewers.ISelectionChangedListener) listeners[i];
treeViewer.addSelectionChangedListener(l);
}
selectionChangedListeners.clear();
org.eclipse.emf.edit.provider.ComposedAdapterFactory adapterFactory = new org.eclipse.emf.edit.provider.ComposedAdapterFactory(org.eclipse.emf.edit.provider.ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
adapterFactory.addAdapterFactory(new org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory());
adapterFactory.addAdapterFactory(new org.eclipse.emf.ecore.provider.EcoreItemProviderAdapterFactory());
adapterFactory.addAdapterFactory(new org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory());
org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider contentProvider = new org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider(adapterFactory);
treeViewer.setAutoExpandLevel(AUTO_EXPAND_LEVEL);
treeViewer.setContentProvider(contentProvider);
treeViewer.setLabelProvider(new org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider(adapterFactory));
org.eclipse.emf.ecore.resource.Resource resource = resourceProvider.getResource();
treeViewer.setInput(resource);
if (resource != null) {
// Select the root object in the view.
treeViewer.setSelection(new org.eclipse.jface.viewers.StructuredSelection(resource), true);
}
treeViewer.setComparator(new org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.PreprocessOutlinePageTreeViewerComparator());
createContextMenu();
createActions();
}
private void createContextMenu() {
// create menu manager
org.eclipse.jface.action.MenuManager menuManager = new org.eclipse.jface.action.MenuManager();
menuManager.setRemoveAllWhenShown(true);
menuManager.addMenuListener(new org.eclipse.jface.action.IMenuListener() {
public void menuAboutToShow(org.eclipse.jface.action.IMenuManager manager) {
fillContextMenu(manager);
}
});
// create menu
org.eclipse.swt.widgets.Menu menu = menuManager.createContextMenu(treeViewer.getControl());
treeViewer.getControl().setMenu(menu);
// register menu for extension
getSite().registerContextMenu("org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.outlinecontext", menuManager, treeViewer);
}
private void fillContextMenu(org.eclipse.jface.action.IMenuManager manager) {
manager.add(new org.eclipse.jface.action.GroupMarker(org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS));
}
private void createActions() {
org.eclipse.ui.part.IPageSite site = getSite();
org.eclipse.ui.IActionBars actionBars = site.getActionBars();
org.eclipse.jface.action.IToolBarManager toolBarManager = actionBars.getToolBarManager();
java.util.List<org.eclipse.jface.action.IAction> actions = new org.servicifi.gelato.language.cobol.preprocess.resource.preprocess.ui.PreprocessOutlinePageActionProvider().getActions(treeViewer);
for (org.eclipse.jface.action.IAction action : actions) {
toolBarManager.add(action);
}
}
public void addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener listener) {
if (getTreeViewer() == null) {
selectionChangedListeners.add(listener);
} else {
getTreeViewer().addSelectionChangedListener(listener);
}
}
public org.eclipse.swt.widgets.Control getControl() {
if (treeViewer == null) {
return null;
}
return treeViewer.getControl();
}
public org.eclipse.jface.viewers.ISelection getSelection() {
if (treeViewer == null) {
return org.eclipse.jface.viewers.StructuredSelection.EMPTY;
}
return treeViewer.getSelection();
}
/**
* Returns this page's tree viewer.
*
* @return this page's tree viewer, or <code>null</code> if
* <code>createControl</code> has not been called yet
*/
protected org.eclipse.jface.viewers.TreeViewer getTreeViewer() {
return treeViewer;
}
public void init(org.eclipse.ui.part.IPageSite pageSite) {
super.init(pageSite);
}
public void removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener listener) {
if (getTreeViewer() == null) {
selectionChangedListeners.remove(listener);
} else {
getTreeViewer().removeSelectionChangedListener(listener);
}
}
public void selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent event) {
if (getTreeViewer() != null) {
getTreeViewer().setSelection(event.getSelection(), true);
}
}
/**
* Sets focus to a part in the page.
*/
public void setFocus() {
treeViewer.getControl().setFocus();
}
public void setSelection(org.eclipse.jface.viewers.ISelection selection) {
if (treeViewer != null) {
treeViewer.setSelection(selection);
}
}
}
| [
"amir.saeidi@mendix.com"
] | amir.saeidi@mendix.com |
a9a440bf06b131e21095189632286d5122e9a82e | 2c5e6c066297c7d394ec036c4912eaac52d3b144 | /mvvmfx/src/test/java/de/saxsys/mvvmfx/internal/viewloader/example/TestFxmlViewWithViewModelWithNonValidInitializeMethodViewWithArguments.java | 278e75839597e54c37a582d1d4ebcd0429b5093e | [
"Apache-2.0"
] | permissive | sialcasa/mvvmFX | 49bacf5cb32657b09a0ccf4cacb0d1c4708c4407 | f195849ca98020ad74056991f147a05db9ce555a | refs/heads/develop | 2023-08-30T00:43:20.250600 | 2019-10-21T14:30:56 | 2019-10-21T14:30:56 | 12,903,179 | 512 | 160 | Apache-2.0 | 2022-06-24T02:09:43 | 2013-09-17T18:16:16 | Java | UTF-8 | Java | false | false | 424 | java | package de.saxsys.mvvmfx.internal.viewloader.example;
import de.saxsys.mvvmfx.FxmlView;
import de.saxsys.mvvmfx.InjectViewModel;
public class TestFxmlViewWithViewModelWithNonValidInitializeMethodViewWithArguments
implements FxmlView<TestViewModelWithNonValidInitializeMethodWithArguments> {
@InjectViewModel
private TestViewModelWithNonValidInitializeMethodWithArguments viewModel;
public void initialize() {
}
}
| [
"manuel.mauky@gmail.com"
] | manuel.mauky@gmail.com |
b46ac6edccd799e849bb0eae131cce4f9f1438ee | 13da461be08ce77ba0fbe3d5ea84cf1437c67624 | /src/main/java/com/camunda/demo/util/CamundaProcessInstanceGenerator/StartProcessInstanceDelegate.java | 71da392dff0f96b4a8bc512cb7f19175db49c8c0 | [] | no_license | camunda-consulting/process-instance-generator | 9156f1790b3c77217e3b6119ccd30cf36df6b3fe | db84797964ac57854a784609ae5c704b220576fb | refs/heads/master | 2020-05-25T15:52:13.566298 | 2018-02-21T10:24:10 | 2018-02-21T10:24:10 | 84,944,720 | 0 | 2 | null | null | null | null | UTF-8 | Java | false | false | 943 | java | package com.camunda.demo.util.CamundaProcessInstanceGenerator;
import java.util.Map;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import com.camunda.demo.util.CamundaProcessInstanceGenerator.helper.RandomUtilTool;
public class StartProcessInstanceDelegate implements JavaDelegate {
RandomUtilTool rando = new RandomUtilTool();
@Override
public void execute(DelegateExecution execution) throws Exception {
String processInstanceKey = (String)execution.getVariable("ProcessKey");
Map<String, Object> vars = (Map<String, Object>)execution.getVariable("procVars");
String busKey = rando.randomUUID();
execution.setVariable("procBusKey", busKey);
execution.getProcessEngineServices().getRuntimeService()
.startProcessInstanceByKey(processInstanceKey, busKey, vars);
//String busKey = (String) execution.getVariable("procBusKey");
}
}
| [
"niall.p.deehan@gmail.com"
] | niall.p.deehan@gmail.com |
b6b62aef09b208784bb34cfe8c18b781130551c4 | 33c34b024cf0c2d6c6967938ef5bdaa1433b2a94 | /spring-security-fundamentals/security-demo/src/main/java/kyocoolcool/security/controller/FileController.java | e2b361a12d0c8507afa18c59122463fecfc6aab1 | [] | no_license | kyocoolcool/spring-integration | 4c6e8dc86834c7470fef97c081e50aa529ce229a | 492e89a3c965f3a3d6d6c2519dbe6601679a182f | refs/heads/master | 2022-12-21T01:39:46.050254 | 2020-03-09T02:10:46 | 2020-03-09T02:10:46 | 204,111,069 | 0 | 0 | null | 2022-12-16T00:02:47 | 2019-08-24T05:05:10 | Java | UTF-8 | Java | false | false | 2,165 | java | package kyocoolcool.security.controller;
import kyocoolcool.security.bean.FileInfo;
import org.apache.commons.io.IOUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.Date;
/**
* @ClassName FileController
* @Description 檔案上傳下載範例
* @Author Chris Chen
* @Date 2019/10/22 5:29 PM
* @Version 1.0
**/
@RestController
@RequestMapping("/file")
public class FileController {
private final String folder = "/Users/chris/git/spring-integration/spring-security-fundamentals/security-demo/src/main/java/kyocoolcool/security/controller";
@PostMapping
public FileInfo upload(MultipartFile file) throws IOException {
System.out.println(file.getName());
System.out.println(file.getOriginalFilename());
System.out.println(file.getSize());
File localFile = new File(folder, new Date().getTime() + ".txt");
file.transferTo(localFile);
return new FileInfo(localFile.getAbsolutePath());
}
@GetMapping("/{id}")
public void download(@PathVariable String id, HttpServletRequest request, HttpServletResponse response) throws IOException {
System.out.println(id);
try (FileInputStream inputStream = new FileInputStream(new File(folder, id + ".txt"));
ServletOutputStream outputStream = response.getOutputStream();) {
// response.setContentType("application/x-download");
// response.setHeader("Content-Disposition", "attachment,filename=test.txt");
response.setHeader("content-type", "application/octet-stream");
response.setContentType("application/octet-stream");
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("test.txt", "UTF-8"));
IOUtils.copy(inputStream, outputStream);
outputStream.flush();
}
}
}
| [
"kyocoolcool@hotmail.com"
] | kyocoolcool@hotmail.com |
a81d7f65389a786370b61c3a354b8d840042e556 | f95b9c1272010857639d30cbc5f5312af8017868 | /TweetsProject/src/com/models/UserModel.java | 34aee1c197a1f1135f60ba909c4cfe37618988a5 | [] | no_license | alexthe228/TwitterFinal | 6d90ed6e73be916a3c0452143a24c9cd566511b6 | b68c15b0d237846e72106fbb03d29a82bd1c8e5d | refs/heads/master | 2021-01-02T08:13:49.127959 | 2014-02-26T14:15:17 | 2014-02-26T14:15:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,633 | java | package com.models;
/*
* Expects a cassandra columnfamily defined as
* use keyspace2;
CREATE TABLE Tweets (
user varchar,
interaction_time timeuuid,
tweet varchar,
PRIMARY KEY (user,interaction_time)
) WITH CLUSTERING ORDER BY (interaction_time DESC);
* To manually generate a UUID use:
* http://www.famkruithof.net/uuid/uuidgen
*/
import java.util.LinkedList;
import com.datastax.driver.core.BoundStatement;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.PreparedStatement;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.Session;
import com.lib.*;
import com.stores.TweetStore;
public class UserModel {
Cluster cluster;
public UserModel(){
}
public void setCluster(Cluster cluster){
this.cluster=cluster;
}
public void addUser(String user, String password, String email)
{
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("insert into Users (user, password, email) values ('"+ user+ "','"+ password +"','" + email + "');");
BoundStatement boundStatement = new BoundStatement(statement);
session.execute(boundStatement);
//ResultSet rs = session.execute(boundStatement);
session.close();
}
public void MakeFriends(String user1, String user2)
{
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("insert into Friends (user1, user2) values ('"+ user1 + "','"+ user2 + "');");
BoundStatement boundStatement = new BoundStatement(statement);
session.execute(boundStatement);
//ResultSet rs = session.execute(boundStatement);
session.close();
}
public void ChangePass(String user, String password)
{
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("update Users set password ='"+ password + "' where user ='"+ user +"';");
BoundStatement boundStatement = new BoundStatement(statement);
session.execute(boundStatement);
//ResultSet rs = session.execute(boundStatement);
session.close();
}
public void ChangeMail(String user, String email)
{
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("update Users set email ='"+ email + "' where user ='"+ user +"';");
BoundStatement boundStatement = new BoundStatement(statement);
session.execute(boundStatement);
//ResultSet rs = session.execute(boundStatement);
session.close();
}
public String getEmail(String user)
{
String email="";
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("select * from Users where user = '"+ user +"';");
BoundStatement boundStatement = new BoundStatement(statement);
ResultSet rs = session.execute(boundStatement);
for (Row row : rs) {
email = row.getString("email");
}
return email;
}
public int Check(String user, String password)
{
String checkpassword="";
Session session = cluster.connect("keyspace2");
PreparedStatement statement = session.prepare("select * from Users where user = '"+ user +"';");
BoundStatement boundStatement = new BoundStatement(statement);
ResultSet rs = session.execute(boundStatement);
if (rs.isExhausted())
{
System.out.println("No such user");
}
else
{
for (Row row : rs) {
checkpassword = row.getString("password");
}
System.out.println(checkpassword);
System.out.println(password);
if (password.endsWith(checkpassword))
{
System.out.println("login sucsessed");
session.close();
return 1;
}
else
System.out.println("incorrect login or password");
}
session.close();
return 0;
}
} | [
"alexthe228@gmail.com"
] | alexthe228@gmail.com |
89c14c46d0c3997a3747da29e2662fcaa296a183 | 3c0e699f75eeb780bfedab8d8505f6f8974ff690 | /src/main/java/io/crypto/beer/telegram/bot/business/validation/dynamic/setting/ClearPersonalDataButtonValidation.java | 78f6a7e7bde0c8c2d746609b21eaeee2c7287998 | [] | no_license | PashaEagle/telegram-bot-2020 | 05c37a060ee1a6d9018bf1426a7f2ed7e7c38b2c | be99dfd22e0e67d56d8f4607b145867479f4eb87 | refs/heads/master | 2020-12-15T17:53:49.095630 | 2020-06-17T23:01:52 | 2020-06-17T23:01:52 | 235,201,228 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 917 | java | package io.crypto.beer.telegram.bot.business.validation.dynamic.setting;
import io.crypto.beer.telegram.bot.engine.entity.Message;
import org.brunocvcunha.instagram4j.Instagram4j;
import org.brunocvcunha.instagram4j.requests.InstagramGetUserFollowingRequest;
import org.brunocvcunha.instagram4j.requests.payload.InstagramGetUserFollowersResult;
import org.brunocvcunha.instagram4j.requests.payload.InstagramLoggedUser;
import org.brunocvcunha.instagram4j.requests.payload.InstagramUser;
import org.brunocvcunha.instagram4j.requests.payload.InstagramUserSummary;
import org.springframework.context.ApplicationContext;
import java.io.IOException;
import java.util.List;
public class ClearPersonalDataButtonValidation {
static Instagram4j instagram4j;
public static boolean validate(Message m, ApplicationContext ctx) {
return !m.getSession().getInstagramSession().isPersonalDataCleared();
}
}
| [
"kolpal17@gmail.com"
] | kolpal17@gmail.com |
6d140f65be9864f09d681959fc360b5e7a640d78 | b3aa4e9fec970f438932508960ff3c382edbef61 | /src/by/it/zhuk/lesson05/TaskC1.java | 69714c256309b62c370fc0c7580dd81aaed9f091 | [] | no_license | ADrachov/CS2019-08-20 | 70ef27dac502d735fe5c83f4d7c793fd8e4f0cfb | 3ddfd5eedaad53513344712619435cc9e7fadf40 | refs/heads/master | 2020-07-08T18:57:34.510154 | 2019-09-03T17:38:37 | 2019-09-03T17:38:37 | 203,749,910 | 0 | 0 | null | 2019-08-22T08:32:37 | 2019-08-22T08:32:37 | null | UTF-8 | Java | false | false | 2,340 | java | package by.it.zhuk.lesson05;
/*
Три массива
1. Введите с клавиатуры 20 чисел, сохраните их в список и рассортируйте по трём другим спискам:
Число делится на 3 (x%3==0), делится на 2 (x%2==0) и все остальные.
Числа, которые делятся на 3 и на 2 одновременно, например 6, попадают в оба списка.
2. Статический метод void printList(List<Integer> list) должен выводить на экран
все элементы переданного ему списка list, каждый элемент - с новой строки.
3. Используя метод printList выведите ваши три списка на экран.
Сначала тот, который для x%3, потом тот, который для x%2, потом последний.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class TaskC1 {
// public static void main(String[] args) throws Exception
// {
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// ArrayList <Integer> list = new ArrayList<>();
// ArrayList <Integer> list3 = new ArrayList<Integer>(); // %3==0
// ArrayList <Integer> list2 = new ArrayList<Integer>(); // %2==0
// ArrayList <Integer> listother = new ArrayList<Integer>(); // other
//
// int size = list.size();
// while (size < 20)
// {
// String s = reader.readLine();
// if (s.isEmpty()) break;
// list.add(Integer.parseInt(s));
// }
// int j;
// for (j = 0; j < size; j++) {
// int x = list.get(j);
// if (x%3 == 0)
// list3.add(x);
// else if (x%2 == 0)
// list2.add(x);
// else
// listother.add(x);
// }
// printList(list3);
// printList(list2);
// printList(listother);
// }
//
// private static void printList(List<Integer> list) {
// for (Integer aList : list) System.out.println(aList);
// }
}
| [
"earl.j.hickey0@gmail.com"
] | earl.j.hickey0@gmail.com |
21442b278168f1a2180fb5f3d0059c7e3d358e2c | 9c83e0f34c046001d55821ae894f7060de86b4dd | /health_common/src/main/java/com/yanglei/content/SmsContent.java | 671690ddcb59605ed450c8091655c209c4969cae | [] | no_license | Git-DazzlingSunShine/health | fd555f933db57ac931169dea578b4d1d1ff1fc67 | 0713b88053a5259cd987f2f532d1ee6e020183b1 | refs/heads/master | 2022-12-24T11:07:25.830330 | 2019-11-17T14:31:21 | 2019-11-17T14:31:21 | 218,969,875 | 1 | 0 | null | 2022-12-16T04:29:28 | 2019-11-01T11:06:35 | JavaScript | UTF-8 | Java | false | false | 134 | java | package com.yanglei.content;
public class SmsContent {
public static final String TOKEN_LLEGAL = "非法请求";//短信预约
}
| [
"1234567@163.com"
] | 1234567@163.com |
b5f7195d6c12fdda99fc68e639945eb249411963 | 1f19aec2ecfd756934898cf0ad2758ee18d9eca2 | /u-1/u-13/u-13-f2524.java | 474e93c1027a49bbc5a51b837ff03f398ba03d95 | [] | no_license | apertureatf/perftest | f6c6e69efad59265197f43af5072aa7af8393a34 | 584257a0c1ada22e5486052c11395858a87b20d5 | refs/heads/master | 2020-06-07T17:52:51.172890 | 2019-06-21T18:53:01 | 2019-06-21T18:53:01 | 193,039,805 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 106 | java | mastercard 5555555555554444 4012888888881881 4222222222222 378282246310005 6011111111111117
3085175798874 | [
"jenkins@khan.paloaltonetworks.local"
] | jenkins@khan.paloaltonetworks.local |
75b8e798e157bf97d12c7728bc71ab61122a165e | 745ee3bda178fd7b6b7a935e1bb99d2288f1da16 | /src/main/java/application/config/WebConfig.java | 2e652cfc524c4207bd9ccbe228d0e57dd811c9ab | [] | no_license | thanhhomedirect/homestore | 984e09a37a37d1fc8899cf42d65ab8d0d7f49184 | a6a5fd2e4204352926b303ad67022e999fd1c70e | refs/heads/master | 2021-05-23T11:15:41.308252 | 2020-07-04T14:26:04 | 2020-07-04T14:26:04 | 253,261,464 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,162 | java | package application.config;
import application.data.service.*;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.tomcat.util.http.LegacyCookieProcessor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.thymeleaf.ThymeleafProperties;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.thymeleaf.spring4.SpringTemplateEngine;
import org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver;
import org.thymeleaf.spring4.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.StandardTemplateModeHandlers;
import org.thymeleaf.templateresolver.FileTemplateResolver;
import org.thymeleaf.templateresolver.ITemplateResolver;
import java.nio.charset.StandardCharsets;
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
private static final Logger logger = LogManager.getLogger(WebConfig.class);
@SuppressWarnings("SpringJavaAutowiringInspection")
@Autowired
private ThymeleafProperties properties;
@Value("${spring.thymeleaf.templates_root:}")
private String templatesRoot;
@Bean
public ITemplateResolver defaultTemplateResolver() {
FileTemplateResolver resolver = new FileTemplateResolver();
resolver.setSuffix(properties.getSuffix());
resolver.setPrefix(templatesRoot);
resolver.setTemplateMode(properties.getMode());
resolver.setCacheable(properties.isCache());
return resolver;
}
@Bean(name = "passwordEncoder")
public PasswordEncoder getPasswordEncoder() {
PasswordEncoder encoder = new BCryptPasswordEncoder();
return encoder;
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler(
"/webjars/**",
"/static/img/**",
"/static/css/**",
"/static/js/**")
.addResourceLocations(
"classpath:/META-INF/resources/webjars/",
"classpath:/static/img/",
"classpath:/static/css/",
"classpath:/static/js/");
}
@Bean
public TomcatEmbeddedServletContainerFactory tomcatEmbedded() {
TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();
tomcat.addConnectorCustomizers((TomcatConnectorCustomizer) connector -> {
if ((connector.getProtocolHandler() instanceof AbstractHttp11Protocol<?>)) {
((AbstractHttp11Protocol<?>) connector.getProtocolHandler()).setMaxSwallowSize(-1);
}
});
return tomcat;
}
/**
* Fix bean cookie
* @return
*/
@Bean
public EmbeddedServletContainerCustomizer customizer() {
return container -> {
if (container instanceof TomcatEmbeddedServletContainerFactory) {
TomcatEmbeddedServletContainerFactory tomcat = (TomcatEmbeddedServletContainerFactory) container;
tomcat.addContextCustomizers(context -> context.setCookieProcessor(new LegacyCookieProcessor()));
}
};
}
}
| [
"thanhtrandung@bitbucket.org"
] | thanhtrandung@bitbucket.org |
e63b12d0ab2edd04356876bd324cb85da4566bf3 | b17f82523725a87928de753623b6516212a05eb3 | /src/main/java/creational/prototype/Sheep.java | 145f8c641dfa79675ff4a5061d91599bb4f9d30e | [] | no_license | pg121380/DesignPatterns | b46a46315e22efbba64182eb135d6eb04d59fe1e | d457e74123ec71c75568ac6bcf3e4fb274c8d714 | refs/heads/master | 2020-06-20T10:50:37.322349 | 2019-07-23T03:49:39 | 2019-07-23T03:49:39 | 197,099,595 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 711 | java | package creational.prototype;
import java.util.Date;
public class Sheep implements Cloneable{
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object clone = super.clone();
return clone;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public Sheep(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
public Sheep(){}
}
| [
"937253559@qq.com"
] | 937253559@qq.com |
9d8d20a1fa42a10ae7e9035ab80bc5bef3f629fa | 160b01428b8deb4b969e456afea0fc3d1ee272d3 | /desbravando-java-orientacao-objetos-casa-do-codigo/src/br/com/casacodigo/capitulo9/Ebook.java | 3251352e10f8b8c4c955c07eb00ef2758b462cf1 | [] | no_license | felipegabriel1942/java-basico-pilares | 25ffbc77585e4bf2a373c9132c78d042bb1a772d | 87b2f90dd8dcbecc5aa0c7ef48f5277b4dfce161 | refs/heads/master | 2020-03-22T18:11:07.864095 | 2018-07-11T17:51:18 | 2018-07-11T17:51:18 | 140,442,878 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 555 | java | package br.com.casacodigo.capitulo9;
public class Ebook extends Livro implements Promocional{
private String marcaDagua;
public Ebook(Autor autor) {
super(autor);
}
public String getMarcaDagua() {
return marcaDagua;
}
public void setMarcaDagua(String marcaDagua) {
this.marcaDagua = marcaDagua;
}
public boolean aplicaDescontoDe(double porcentagem) {
if(porcentagem > 0.15) {
return false;
}
this.setValor(this.getValor() - (this.getValor() * porcentagem));
return true;
}
}
| [
"pinheiro_felipeg@yahoo.com.br"
] | pinheiro_felipeg@yahoo.com.br |
2e7ad5f5e71f00590620cc869cb836fa950cf1cb | 6fc3d6112c729c00d8ad489f87f7725d3477f85c | /TBGameFramework/src/tbgameframework/utils/collections/CollectionConverter.java | 6c22d1ffb53f7b78aa69518837f59dd4a00e1372 | [] | no_license | acquydem12/field-runner | f90d587503af386503eb6b5a5fd1ee9efec26f96 | 6fa736611a95fded131cd36dade41caa01b11ae5 | refs/heads/master | 2016-09-01T19:43:58.947467 | 2015-03-14T15:27:57 | 2015-03-14T15:27:57 | 32,215,517 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 1,121 | java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package tbgameframework.utils.collections;
import tbgameframework.utils.factory.Factory;
import java.util.Collection;
import java.util.HashSet;
/**
*
* @author Uchiha Salm
*/
public class CollectionConverter
{
public static <E> Collection<E> convert(Collection<? extends E> convertee, Collection<E> converted)
{
for (E item : convertee)
{
converted.add(item);
}
return converted;
}
/**
* default is Hash Set
* @param <E>
* @param convertee
* @return
*/
public static <E> Collection<E> convert(Collection<? extends E> convertee)
{
Collection<E> converted = new HashSet<>();
return convert(convertee, converted);
}
public static <E> Collection<E> convert(Collection<? extends E> convertee, Factory<Collection<E>> convertedFactory)
{
Collection<E> converted = convertedFactory.createProduct();
return convert(convertee, converted);
}
}
| [
"mrkupi149@gmail.com"
] | mrkupi149@gmail.com |
edecfbd4069e251ba0ce65e7b951717ead1a6af2 | 9ef98478a8b811b6b18f33e4f2daf07676117317 | /android/app/src/androidTest/java/org/tensorflow/lite/cassava/ClassifierTest.java | a7719d5d2d468b86d34bf0a16d1a3c9e8ef98d54 | [] | no_license | rpnugroho/cassava-disease-tflite | 52fea99ed82496d034e45751ae3380dd3827d62b | 67ae9e558d723572791d88d0f3e02ce5405658db | refs/heads/main | 2023-03-03T00:29:02.958103 | 2021-02-17T15:18:53 | 2021-02-17T15:18:53 | 328,590,235 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,042 | java | /*
* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
*
* 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 org.tensorflow.lite.cassava;
import static com.google.common.truth.Truth.assertThat;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.rule.ActivityTestRule;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.tensorflow.lite.cassava.tflite.Classifier;
/** Golden test for Image Classification Reference app. */
@RunWith(AndroidJUnit4.class)
public class ClassifierTest {
@Rule
public ActivityTestRule<ClassifierActivity> rule =
new ActivityTestRule<>(ClassifierActivity.class);
private static final String[] INPUTS = {"fox.jpg"};
private static final String[] GOLDEN_OUTPUTS = {"fox-mobilenet_v1_1.0_224.txt"};
@Test
public void classificationResultsShouldNotChange() throws IOException {
ClassifierActivity activity = rule.getActivity();
Classifier classifier = Classifier.create(activity, Classifier.Device.CPU, 1);
for (int i = 0; i < INPUTS.length; i++) {
String imageFileName = INPUTS[i];
String goldenOutputFileName = GOLDEN_OUTPUTS[i];
Bitmap input = loadImage(imageFileName);
List<Classifier.Recognition> goldenOutput = loadRecognitions(goldenOutputFileName);
List<Classifier.Recognition> result = classifier.recognizeImage(input, 0);
Iterator<Classifier.Recognition> goldenOutputIterator = goldenOutput.iterator();
for (Classifier.Recognition actual : result) {
Assert.assertTrue(goldenOutputIterator.hasNext());
Classifier.Recognition expected = goldenOutputIterator.next();
assertThat(actual.getTitle()).isEqualTo(expected.getTitle());
assertThat(actual.getConfidence()).isWithin(0.01f).of(expected.getConfidence());
}
}
}
private static Bitmap loadImage(String fileName) {
AssetManager assetManager =
InstrumentationRegistry.getInstrumentation().getContext().getAssets();
InputStream inputStream = null;
try {
inputStream = assetManager.open(fileName);
} catch (IOException e) {
Log.e("Test", "Cannot load image from assets");
}
return BitmapFactory.decodeStream(inputStream);
}
private static List<Classifier.Recognition> loadRecognitions(String fileName) {
AssetManager assetManager =
InstrumentationRegistry.getInstrumentation().getContext().getAssets();
InputStream inputStream = null;
try {
inputStream = assetManager.open(fileName);
} catch (IOException e) {
Log.e("Test", "Cannot load probability results from assets");
}
Scanner scanner = new Scanner(inputStream);
List<Classifier.Recognition> result = new ArrayList<>();
while (scanner.hasNext()) {
String category = scanner.next();
category = category.replace('_', ' ');
if (!scanner.hasNextFloat()) {
break;
}
float probability = scanner.nextFloat();
Classifier.Recognition recognition = new Classifier.Recognition(null, category, probability, null);
result.add(recognition);
}
return result;
}
}
| [
"nugroho.rizkyp@gmail.com"
] | nugroho.rizkyp@gmail.com |
abf23de439c56562239945f4927ecb42e4e807b2 | aad08ec60bdfc23e1f33457723127c8f10e51023 | /forum/src/main/java/com/alura/forum/model/Perfil.java | 29c1270d0df7c156e476143c76d1219b979c7feb | [] | no_license | leomontagnolli/SpringBoot-Alura | 871a8c1f9c56cdb889f3b726e00d1b9c0091711a | 1f21cf783d2cf18c0da1d1f1584ca66a72151768 | refs/heads/master | 2022-07-15T15:08:19.643401 | 2020-05-21T22:07:32 | 2020-05-21T22:07:32 | 263,394,246 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 713 | java | package com.alura.forum.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import org.springframework.security.core.GrantedAuthority;
@Entity
public class Perfil implements GrantedAuthority {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String nome;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
@Override
public String getAuthority() {
return nome;
}
}
| [
"leomontagnolli@gmail.com"
] | leomontagnolli@gmail.com |
35096f39218bd5269bffd30b3c680fb743702cfd | dd530ad96ff3f5a05538a04ace6f6e77189d5a65 | /lab3.1/my-app/src/main/java/com/mycompany/app/supermarket/model/processors/IProductProcessor.java | 71cd3c34597eec8d19ee8592f8faeecdc42c2833 | [] | no_license | protasov-ilja/Java | d2119b7ad3cdb5b5db43c09eaa3e795cc44774d0 | 8d0c29ceb0c0fdba74df833a2308da1a7acf5de4 | refs/heads/master | 2021-06-27T09:41:10.852968 | 2019-07-06T21:00:29 | 2019-07-06T21:00:29 | 154,735,910 | 0 | 0 | null | 2020-10-13T14:24:13 | 2018-10-25T20:50:43 | HTML | UTF-8 | Java | false | false | 334 | java | package com.mycompany.app.supermarket.model.processors;
import com.mycompany.app.product.Product;
import javafx.util.Pair;
import java.util.List;
public interface IProductProcessor {
void addProducts(List<Pair<Product, Float>> products);
List<Pair<Product, Float>> getProducts();
void checkProductResidue(int productIndex);
}
| [
"ilya.protasov@omega-r.com"
] | ilya.protasov@omega-r.com |
1d5f24e5feea3753c17f38667eec0717f2d76e1e | 8ef059a4ae72ba60d312d069930943678f55e442 | /src/main/java/com/MeetingRoom/MRBS/resources/LoginRest.java | bebc5430586d39ab750ff9e44924bcfa5c862c28 | [] | no_license | Akhilsai7/MeetingRoomBookingSystemRest | fd659e79a56d6c8b7c18824d62de49554d9f32b6 | 40720daf87b6a01004e5fe667108b06be3e93c09 | refs/heads/master | 2022-07-19T22:56:54.816840 | 2022-02-10T05:23:50 | 2022-02-10T05:23:50 | 203,997,731 | 0 | 0 | null | 2022-06-21T04:24:02 | 2019-08-23T12:50:37 | Java | UTF-8 | Java | false | false | 934 | java | package com.MeetingRoom.MRBS.resources;
import java.io.IOException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.ws.rs.FormParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import com.MeetingRoom.MRBS.bean.LoginBean;
import com.MeetingRoom.MRBS.Controller.*;
@Path("LoginRest")
public class LoginRest {
@POST
@Path("/Login")
@Produces(MediaType.APPLICATION_JSON)
public LoginBean Login(LoginBean login) {
LoginBean login2;
EntityManagerFactory emf = Persistence.createEntityManagerFactory("MRBS");
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
login2 = em.find(LoginBean.class, login.getUsername());
em.getTransaction().commit();
System.out.println(login2);
return login2;
}
}
| [
"akhil.bejugam@gmail.com"
] | akhil.bejugam@gmail.com |
3d574d91d05b5a5f644a2d8f524049fc8ddbc275 | c885ef92397be9d54b87741f01557f61d3f794f3 | /results/JacksonCore-25/com.fasterxml.jackson.core.json.ReaderBasedJsonParser/BBC-F0-opt-60/tests/8/com/fasterxml/jackson/core/json/ReaderBasedJsonParser_ESTest.java | 85b233ccdd52dd71a34d1a996e41277cc1f86b20 | [
"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 | 7,409,440 | java | /*
* This file was automatically generated by EvoSuite
* Thu Oct 14 03:14:41 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.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.RequestPayload;
import com.fasterxml.jackson.core.util.TextBuffer;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.FileDescriptor;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
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.MockFile;
import org.evosuite.runtime.mock.java.io.MockFileOutputStream;
import org.evosuite.runtime.mock.java.io.MockPrintStream;
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();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("nullZarky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '}';
charArray0[1] = 's';
charArray0[2] = '2';
charArray0[3] = 'y';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 576, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(576, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'}', 's', '2', 'y'}, charArray0);
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(4, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nullZarky': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test001() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("9E1,Ig");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = '*';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charArray0[1] = 'r';
charArray0[2] = 'r';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 91, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'*', 'r', 'r'}, charArray0);
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(3, charArray0.length);
readerBasedJsonParser0.getCurrentToken();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'*', 'r', 'r'}, charArray0);
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(3, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test002() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("nullZarky");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nullZarky': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test003() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("nullZarky");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotNull(readerBasedJsonParser0);
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(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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nullZarky': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test004() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("nullZarky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nullZarky': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test005() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("eUSE4|A*#8l6'1RKLn");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("Fcr");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec2).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec2).toString();
char[] charArray0 = new char[5];
charArray0[0] = '`';
charArray0[1] = '$';
charArray0[2] = ',';
charArray0[3] = '+';
charArray0[4] = ',';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec2, charsToNameCanonicalizer1, charArray0, (-1288), 35, false);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '$', ',', '+', ','}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(treeNode0);
assertArrayEquals(new char[] {'`', '$', ',', '+', ','}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 785, stringReader1, objectCodec1, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(785, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._isNextTokenNameMaybe(39, "eUSE4|A*#8l6'1RKLn");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test006() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(boolean0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = 'Z';
charArray0[1] = 'E';
charArray0[2] = 'Z';
charArray0[3] = '>';
charArray0[4] = '!';
charArray0[5] = '';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 94, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 33, 13, true);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(94, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'Z', 'E', 'Z', '>', '!', ''}, charArray0);
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(6, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextBooleanValue();
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test007() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(boolean0);
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);
readerBasedJsonParser0._tokenIncomplete = false;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
int int0 = readerBasedJsonParser0.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, int0);
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);
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(charArray0);
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);
}
@Test(timeout = 4000)
public void test008() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("fa}IR!sFS/CL");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fa': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test009() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("3^owH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getInputSource();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(object0, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(object0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
byte[] byteArray0 = iOContext2.allocReadIOBuffer();
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 44, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(44, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertSame(stringReader0, object0);
assertEquals(51, int0);
try {
readerBasedJsonParser1._isNextTokenNameMaybe(102, "Unexpected end-of-input within/between ");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): was expecting a colon to separate field name and value
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test010() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("TYaTI94~");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 200, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._handleOddName(1116);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test011() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("/*s5Z-L0");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1915, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1915, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1915, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(object0);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("/*s5Z-L0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = '\"';
charArray0[1] = 'x';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 91, stringReader1, objectCodec1, charsToNameCanonicalizer3, charArray0, 2, (-3240), false);
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(91, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\"', 'x'}, charArray0);
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);
assertEquals(2, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a comment
// at [Source: UNKNOWN; line: 1, column: -3229]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test012() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("/*s5Z-L0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a comment
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test013() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(" entriecs");
assertNotNull(stringReader0);
byte[] byteArray0 = iOContext0.allocBase64Buffer(51);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getInputSource();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(object0, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 58, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(58, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1._isNextTokenNameMaybe(116, " entriecs");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('e' (code 101)): was expecting a colon to separate field name and value
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test014() throws Throwable {
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "false", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = '\\';
charArray0[1] = 'T';
charArray0[2] = '!';
charArray0[3] = '.';
charArray0[4] = '?';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 123, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 108, 108, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', 'T', '!', '.', '?'}, charArray0);
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(5, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(110, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(10, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(109L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isBoolean());
assertEquals(10, jsonToken0.id());
assertEquals("false", jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(JsonToken.VALUE_FALSE, jsonToken0);
assertArrayEquals(new char[] {'f', 'a', 'l', 's', 'e'}, charArray0);
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(5, charArray0.length);
}
@Test(timeout = 4000)
public void test015() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'm<s+jxeU");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(string0);
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);
try {
readerBasedJsonParser0.getValueAsString("\"Kmk'm<s+jxeU");
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test016() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "}4NaO I4~", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = '4';
charArray0[1] = '4';
charArray0[2] = '0';
charArray0[3] = 'T';
charArray0[4] = '4';
charArray0[5] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 43, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '4', '0', 'T', '4', '4'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(6, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("}4NaO I4~", jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals('4', char0);
assertArrayEquals(new char[] {'4', '4', '0', 'T', '4', '4'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(6, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('T' (code 84)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test017() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(2353);
assertEquals(2353, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("Current token (%s) not numeric, can not use numeric value accessors");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '0';
charArray0[2] = '(';
charArray0[3] = 'U';
charArray0[4] = 'M';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 13, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'0', '\u0000', '(', 'U', 'M'}, charArray0);
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);
assertEquals(5, charArray0.length);
StringReader stringReader1 = new StringReader("Current token (%s) not numeric, can not use numeric value accessors");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 0)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test018() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("null/arky");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[5];
charArray0[0] = '9';
charArray0[1] = 'i';
charArray0[2] = '}';
charArray0[3] = '[';
charArray0[4] = 'S';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 580, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2353, 3, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(580, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'9', 'i', '}', '[', 'S'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals("null", jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertEquals(11, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_NULL, jsonToken0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser1._releaseBuffers();
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test019() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(184);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
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(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 681, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(681, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
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(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(681, readerBasedJsonParser0.getFeatureMask());
assertEquals(10, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
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));
assertFalse(boolean0);
assertNotNull(boolean0);
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);
}
@Test(timeout = 4000)
public void test020() throws Throwable {
StringReader stringReader0 = new StringReader("~]t=q, ?1i%2~");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "~]t=q, ?1i%2~", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotNull(textBuffer0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._handleInvalidNumberStart(73, true);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('~' (code 126)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test021() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("})m-$,5}'K_R[YE9(");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1029), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1029), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0._parseAposName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1029), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("})m-$,5}", string0);
assertNotNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test022() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3022, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3022, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(3022, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(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);
try {
readerBasedJsonParser0.getTextOffset();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test023() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1588), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1588), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1588), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(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(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);
int int0 = readerBasedJsonParser0.getTextLength();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1588), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(23, 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(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);
}
@Test(timeout = 4000)
public void test024() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(boolean0);
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);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("\"Kmk'msG+jxe{");
assertEquals("\"Kmk'msG+jxe{", serializedString0.toString());
assertEquals("\"Kmk'msG+jxe{", serializedString0.getValue());
assertEquals(13, serializedString0.charLength());
assertNotNull(serializedString0);
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: UNKNOWN; line: 1, column: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test025() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("pE[n0r2QA/7iW& @@a");
assertNotNull(mockFileOutputStream0);
StringReader stringReader0 = new StringReader("pE[n0r2QA/7iW& @@a");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2031);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '2';
charArray0[1] = 'M';
charArray0[2] = 'P';
charArray0[3] = 's';
charArray0[4] = 'B';
charArray0[5] = '2';
charArray0[6] = 'B';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 72, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 22, 1, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(72, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'2', 'M', 'P', 's', 'B', '2', 'B'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)92;
byteArray0[1] = (byte) (-36);
// Undeclared exception!
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, mockFileOutputStream0, 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 test026() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
Integer integer0 = new Integer((-217));
assertEquals((-217), (int)integer0);
assertNotNull(integer0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "W$bRj5=0oHcR,", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[1] = 'Z';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 0, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'Z'}, charArray0);
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(2, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-516), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = readerBasedJsonParser1._handleApos();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
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);
Boolean boolean0 = readerBasedJsonParser1.nextBooleanValue();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(57L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(9, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(58, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(9, readerBasedJsonParser1.getCurrentTokenId());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertTrue(boolean0);
assertNotNull(boolean0);
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);
}
@Test(timeout = 4000)
public void test027() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\":O^ePt1PI5");
assertNotNull(stringReader0);
String string0 = "";
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
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);
try {
readerBasedJsonParser0.getValueAsString();
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: 23]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test028() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals(39, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = '(';
charArray0[1] = '';
charArray0[2] = 'B';
charArray0[3] = '_';
charArray0[4] = 'b';
charArray0[5] = '<';
charArray0[6] = '.';
charArray0[7] = 'M';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 13, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 8, 2, true);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(13, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'(', '', 'B', '_', 'b', '<', '.', 'M'}, charArray0);
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);
assertEquals(8, 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 test029() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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(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);
try {
readerBasedJsonParser0.finishToken();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test030() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'trVe', 'false' or 'null')");
assertNotNull(stringReader0);
Integer integer0 = new Integer(6);
assertEquals(6, (int)integer0);
assertNotNull(integer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '';
charArray0[1] = 'Z';
charArray0[3] = 'V';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3030, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 116, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, 2, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 116, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = readerBasedJsonParser1._handleApos();
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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(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);
try {
readerBasedJsonParser1.nextLongValue(0L);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'trVe': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 61]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test031() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("3EP~4P6P:");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TVZpxqx", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
byte[] byteArray0 = iOContext0.allocReadIOBuffer(3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(8000, byteArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, "TVZpxqx", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader2 = new StringReader("3EP~4P6P:");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 34, stringReader2, objectCodec0, charsToNameCanonicalizer1, charArray0, 85, 3063, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(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(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(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: UNKNOWN; line: 1, column: 3082]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test032() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, "6", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3840), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3840), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals((-3840), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(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);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals((-3840), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, int0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.getText((Writer) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.util.TextBuffer", e);
}
}
@Test(timeout = 4000)
public void test033() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.nextIntValue(0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.getValueAsString("");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals("", string0);
assertNotNull(string0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test034() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, "3EP~4P6P:", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
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(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = '^';
charArray0[1] = '?';
charArray0[2] = '>';
charArray0[3] = 'E';
charArray0[4] = 'b';
charArray0[5] = 'x';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-869), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 43, true);
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.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-869), readerBasedJsonParser0.getFeatureMask());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'^', '?', '>', 'E', 'b', 'x'}, charArray0);
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);
assertEquals(6, charArray0.length);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
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.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-869), readerBasedJsonParser0.getFeatureMask());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNull(treeNode0);
assertArrayEquals(new char[] {'^', '?', '>', 'E', 'b', 'x'}, charArray0);
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);
assertEquals(6, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("3EP~4P6P:");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader2 = new StringReader("");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
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));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 0, stringReader1, objectCodec1, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
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(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
readerBasedJsonParser1._skipCR();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
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(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
try {
readerBasedJsonParser1._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('P' (code 80)) in numeric value: Exponent indicator not followed by a digit
// at [Source: UNKNOWN; line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test035() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 219, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 126, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
StringReader stringReader1 = new StringReader("N~");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0.getValueAsString("");
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test036() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 125, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(125, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(125, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 57, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(57, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(stringReader0.equals((Object)stringReader1));
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));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser1._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 test037() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(870);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'T';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 870, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'T', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'T', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, false);
assertFalse(boolean0);
SerializedString serializedString0 = new SerializedString("Aw^hFuS K%,p");
assertEquals("Aw^hFuS K%,p", serializedString0.getValue());
assertEquals("Aw^hFuS K%,p", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertNotNull(serializedString0);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertArrayEquals(new char[] {'T', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 51, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(51, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string1 = readerBasedJsonParser1.getValueAsString();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(51, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(2, jsonLocation0.getLineNr());
assertEquals(1L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNotNull(jsonLocation0);
assertArrayEquals(new char[] {'T', '\"', '4', '\"'}, charArray0);
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);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(4, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('\"' (code 34)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test038() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(870);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'Q';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 870, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("Aw^hFuS K%,p");
assertEquals("Aw^hFuS K%,p", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("Aw^hFuS K%,p", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals("Aw^hFuS K%,p", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("Aw^hFuS K%,p", serializedString0.getValue());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean0);
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("");
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("4", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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);
assertEquals(4, charArray0.length);
}
@Test(timeout = 4000)
public void test039() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(870);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(8000, byteArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'Q';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 870, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("Aw^hFuS K%,p");
assertEquals("Aw^hFuS K%,p", serializedString0.toString());
assertEquals("Aw^hFuS K%,p", serializedString0.getValue());
assertEquals(12, serializedString0.charLength());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals("Aw^hFuS K%,p", serializedString0.toString());
assertEquals("Aw^hFuS K%,p", serializedString0.getValue());
assertEquals(12, serializedString0.charLength());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean0);
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._finishString();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'Q', '\"', '4', '\"'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.getValueAsString("null array");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 4
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test040() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INp");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
boolean boolean0 = stringReader0.ready();
assertTrue(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "+INp");
assertFalse(boolean1 == boolean0);
assertFalse(boolean1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2086), 4, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(1, charArray0.length);
boolean boolean2 = readerBasedJsonParser0._loadMore();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertTrue(boolean2 == boolean0);
assertFalse(boolean2 == boolean1);
assertTrue(boolean2);
assertArrayEquals(new char[] {'+'}, charArray0);
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);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("\nRequest payload : ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1026, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1026, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Request': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test041() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// 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 test042() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader("9E1,Ig");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "was expecting a colon to separate field name and value");
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(9);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test043() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, "[G+\r]", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("[G+\r]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2041, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2041, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._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: 11]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test044() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
try {
readerBasedJsonParser0.getValueAsString();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test045() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[1];
charArray0[0] = '';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, (-523), false);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {''}, charArray0);
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(1, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('@' (code 64)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: -520]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test046() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1742, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1742, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
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);
int int0 = readerBasedJsonParser0.nextIntValue(2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1742, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, int0);
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);
int int1 = readerBasedJsonParser0.nextIntValue((-1089));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1742, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(int1 == int0);
assertEquals((-1089), int1);
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);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1742, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertNotNull(jsonLocation0);
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);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
}
@Test(timeout = 4000)
public void test047() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals(39, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[1] = 'g';
charArray0[2] = '-';
charArray0[3] = 'k';
charArray0[5] = '=';
charArray0[6] = '!';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-492), 1294, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'g', '-', 'k', '\u0000', '=', '!', '\u0000', '\u0000'}, charArray0);
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(9, charArray0.length);
Object object0 = readerBasedJsonParser0.getTypeId();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(object0);
assertArrayEquals(new char[] {'\u0000', 'g', '-', 'k', '\u0000', '=', '!', '\u0000', '\u0000'}, charArray0);
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(9, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._handleOddName(39);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (''' (code 39)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test048() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "0@nLQoKPlzT%xb%";
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "0@nLQoKPlzT%xb%", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[1];
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isScalarValue());
assertEquals(5, jsonToken0.id());
assertEquals(JsonToken.FIELD_NAME, jsonToken0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test049() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "6");
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
int int0 = 56;
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 56, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(56, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(56, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(boolean1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertFalse(jsonEncoding1.equals((Object)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);
StringReader stringReader1 = new StringReader("Decimal point not followed by a digit");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser0.getTextOffset();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test050() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 102, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(boolean1);
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);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = readerBasedJsonParser0.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0, int0);
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);
readerBasedJsonParser0.nextToken();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
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);
}
@Test(timeout = 4000)
public void test051() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer((-1090));
assertEquals((-1090), (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "was expecting a colon to separate field name and value");
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(boolean1);
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);
StringReader stringReader1 = new StringReader("was expecting a colon to separate field name and value");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = readerBasedJsonParser0.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0, 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(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);
readerBasedJsonParser0.nextToken();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(stringReader0, stringReader1);
assertFalse(integer0.equals((Object)int0));
assertFalse(stringReader0.equals((Object)stringReader1));
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);
}
@Test(timeout = 4000)
public void test052() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
try {
readerBasedJsonParser0.getText();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test053() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
try {
readerBasedJsonParser0.getText();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test054() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("null/!arky");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 51, 0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNull(string0);
assertArrayEquals(new char[] {'/'}, charArray1);
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(1, charArray1.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('!' (code 33)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test055() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(117);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.nextLongValue((-767L));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test056() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(57);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("ty9S^zg8bO%g?oPbG");
assertNotNull(stringReader0);
char[] charArray0 = new char[6];
charArray0[0] = '\u000F';
charArray0[1] = '\u000F';
charArray0[2] = '\u000F';
charArray0[3] = '\u000F';
charArray0[4] = '\u000F';
charArray0[5] = '\u000F';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4322), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 1, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-4322), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u000F', '\u000F', '\u000F', '\u000F', '\u000F', '\u000F'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(6, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ty9S': was expecting 'null', 'true', 'false' or NaN
// at [Source: (String)\"TTI94~ \"; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test057() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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(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);
try {
readerBasedJsonParser0.nextToken();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test058() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+INF", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = bufferRecycler0.allocCharBuffer(1, 1);
assertNotNull(charArray0);
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(4000, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("-{_");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals(45, int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2645), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2645), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextTextValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-2645), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(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);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-2645), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals(0L, jsonLocation0.getCharOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
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);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(129);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test059() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
StringReader stringReader0 = new StringReader("[G+\r]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("{nr");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
boolean boolean0 = stringReader1.markSupported();
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(boolean0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(byteArray0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(8000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1399), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-1399), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1399), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertEquals("{", jsonToken0.asString());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(JsonToken.START_OBJECT, jsonToken0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean1 = readerBasedJsonParser0.getValueAsBoolean();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1399), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(boolean1 == boolean0);
assertFalse(boolean1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test060() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(121);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 103, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(103, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(103, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(103, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(1, int0);
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);
}
@Test(timeout = 4000)
public void test061() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "|K+MBSh~y$BxvQ\"oJ0R*", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("Oao7!~XJ~zA", true);
assertNotNull(mockFileOutputStream0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'Q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 48, (byte)125, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'Q'}, charArray0);
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(1, charArray0.length);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)82;
byteArray0[1] = (byte)87;
byteArray0[2] = (byte)125;
byteArray0[3] = (byte)87;
byteArray0[4] = (byte) (-77);
byteArray0[5] = (byte)125;
byteArray0[6] = (byte) (-77);
byteArray0[7] = (byte)87;
// Undeclared exception!
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, mockFileOutputStream0, byteArray0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 48
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test062() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-INF", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = '\u0015';
charArray0[1] = 'C';
charArray0[2] = '\u0015';
charArray0[3] = '\u0015';
charArray0[4] = '\u0015';
charArray0[5] = '\u0015';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1888, stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 33, 0, false);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1888, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0015', 'C', '\u0015', '\u0015', '\u0015', '\u0015'}, charArray0);
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(6, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("0@nLQoKPlpT%xb%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1888, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(string0);
assertArrayEquals(new char[] {'-', 'I', 'N', 'F', '\u0015', '\u0015'}, charArray0);
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(6, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1888, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(charArray1, charArray0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray0, charArray1);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(charArray1);
assertArrayEquals(new char[] {'-', 'I', 'N', 'F'}, charArray1);
assertArrayEquals(new char[] {'-', 'I', 'N', 'F', '\u0015', '\u0015'}, charArray0);
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(4, charArray1.length);
assertEquals(6, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(0L, jsonLocation0.getCharOffset());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1888, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray0, charArray1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(jsonLocation0);
assertArrayEquals(new char[] {'-', 'I', 'N', 'F', '\u0015', '\u0015'}, charArray0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(6, charArray0.length);
}
@Test(timeout = 4000)
public void test063() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
try {
readerBasedJsonParser0.getTextLength();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test064() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\u0015';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 219, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 126, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0015', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Z");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Illegal character ((CTRL-CHAR, code 21)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test065() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, charsToNameCanonicalizer0, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Leading': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test066() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-847));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '%';
charArray0[1] = 'Q';
charArray0[2] = '?';
charArray0[3] = 'L';
charArray0[4] = 'Q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1743), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 33, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1743), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'%', 'Q', '?', 'L', 'Q'}, charArray0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test067() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-631), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 3264, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-631), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(3, charArray0.length);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-631), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(boolean0);
assertArrayEquals(new char[] {'-', '4', '.'}, charArray0);
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);
assertEquals(3, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('-' (code 45)) in numeric value: Decimal point not followed by a digit
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 3269]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test068() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 684, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser0._tokenIncomplete = true;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
try {
readerBasedJsonParser0.nextFieldName();
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: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test069() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 219, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 126, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
StringReader stringReader1 = new StringReader("Z");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec1, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test070() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = '?';
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
boolean boolean1 = stringReader0.markSupported();
assertTrue(boolean1 == boolean0);
assertTrue(boolean1);
charArray0[1] = '{';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2553), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 33, true);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-2553), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'?', '{'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)107;
byteArray0[1] = (byte)98;
byteArray0[2] = (byte)25;
byteArray0[3] = (byte) (-123);
byteArray0[4] = (byte)115;
boolean boolean2 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean2 == boolean0);
assertFalse(boolean2 == boolean1);
assertFalse(boolean2);
assertArrayEquals(new byte[] {(byte)107, (byte)98, (byte)25, (byte) (-123), (byte)115}, byteArray0);
assertEquals(5, byteArray0.length);
boolean boolean3 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "false");
assertFalse(boolean3 == boolean0);
assertFalse(boolean3 == boolean1);
assertTrue(boolean3 == boolean2);
assertFalse(boolean3);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-2553), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(string0);
assertArrayEquals(new char[] {'?', '{'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
Boolean boolean4 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(35, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2553), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(34L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(10, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(boolean4.equals((Object)boolean1));
assertTrue(boolean4.equals((Object)boolean2));
assertTrue(boolean4.equals((Object)boolean3));
assertFalse(boolean4.equals((Object)boolean0));
assertFalse(boolean4);
assertNotNull(boolean4);
assertArrayEquals(new char[] {'e', 's'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 41]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test071() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.type.TypeReference");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("6");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = 'm';
charArray0[1] = '2';
int int0 = stringReader0.read(charArray0);
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(2, int0);
assertArrayEquals(new char[] {'c', 'o'}, charArray0);
assertEquals(2, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 34, 33, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'c', 'o'}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
assertEquals(2, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'m', '.'}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
assertEquals(2, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertTrue(boolean0);
assertArrayEquals(new char[] {'f', 'a'}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
assertEquals(2, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fasterxml': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 2, column: 12]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test072() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, "W2tt", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("W2tt");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1144, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1144, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("IGNORE_UNDEFINED");
assertEquals(16, serializedString0.charLength());
assertEquals("IGNORE_UNDEFINED", serializedString0.toString());
assertEquals("IGNORE_UNDEFINED", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'W2tt': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test073() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = iOContext0.allocTokenBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray1 = new char[2];
assertFalse(charArray1.equals((Object)charArray0));
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-225), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray1, 38, 38, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-225), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray1.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('P' (code 80)) in numeric value: Exponent indicator not followed by a digit
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 42]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test074() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 110, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
try {
readerBasedJsonParser0._reportInvalidToken("Q QXV{2_F5iC$,ltS");
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 test075() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(256);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler1, charsToNameCanonicalizer1, false);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
byte[] byteArray0 = iOContext2.allocReadIOBuffer();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(byteArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(8000, byteArray0.length);
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '4';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 3, stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 3, 102, true);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '\"', '\"', '\"'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertArrayEquals(new char[] {'4', '\"', '\"', '\"'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(boolean0);
assertArrayEquals(new char[] {'4', '\"', '\"', '\"'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.getTextCharacters();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 4
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test076() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2003));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = ' ';
charArray0[1] = ',';
charArray0[2] = ' ';
charArray0[3] = ' ';
charArray0[4] = ' ';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(56);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1154), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 33, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-1154), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {' ', ',', ' ', ' ', ' '}, charArray0);
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(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test077() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
charArray0[0] = ' ';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(33);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 219, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 126, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {' ', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
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: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test078() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(113);
assertEquals(113, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
char[] charArray0 = new char[4];
charArray0[0] = ' ';
charArray0[1] = ' ';
charArray0[2] = ' ';
charArray0[3] = ' ';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 110, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 9, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(110, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {' ', ' ', ' ', ' '}, charArray0);
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);
assertEquals(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 4
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test079() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.type.TypeReference");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("6");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'd';
charArray0[1] = 'x';
charArray0[2] = 't';
charArray0[3] = 'H';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 108, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'d', 'x', 't', 'H'}, charArray0);
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);
assertEquals(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 101, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(101, readerBasedJsonParser1.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
String string0 = readerBasedJsonParser1.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(7, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(101, readerBasedJsonParser1.getFeatureMask());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
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);
char[] charArray1 = readerBasedJsonParser1.getTextCharacters();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(7, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(101, readerBasedJsonParser1.getFeatureMask());
assertNotSame(charArray1, charArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(charArray1);
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);
assertEquals(200, charArray1.length);
}
@Test(timeout = 4000)
public void test080() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("30]gZ8iip9w+");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (']' (code 93)): 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 test081() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 2, (-161), 2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
charArray0[5] = '\"';
charArray0[3] = '\"';
charArray0[4] = '\"';
charArray0[6] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 272, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\"', '\"', '\"', '\"', '\u0000'}, charArray0);
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(8, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'D', 'V', 'K', '_', '\'', 'O', '|', '6'}, charArray0);
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(8, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(104);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(boolean0);
assertArrayEquals(new char[] {'f', '', 'g', '_', '8', '7', '|', '6'}, charArray0);
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(8, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('\f', char0);
assertArrayEquals(new char[] {'f', '', 'g', '_', '8', '7', '|', '6'}, charArray0);
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(8, charArray0.length);
}
@Test(timeout = 4000)
public void test082() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2173), stringReader0, objectCodec0, charsToNameCanonicalizer3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2173), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2173), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test083() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext0 = new IOContext(bufferRecycler0, jsonEncoding0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(12);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("0@nLQoKPlzT%xb%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(3229);
assertEquals(3229, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler1, integer0, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2201, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2201, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0._handleOddName(100);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2201, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals("0@nLQoKPlzT", string0);
assertNotNull(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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 31]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test084() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("expected a value");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 73, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals('e', char0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(118);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test085() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+I");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 33, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D'}, charArray0);
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);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a Number value
// at [Source: UNKNOWN; line: 1, column: 37]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test086() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("name");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 114, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(0L);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'name': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test087() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 33, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D'}, charArray0);
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(1, charArray0.length);
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: UNKNOWN; line: 1, column: 39]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test088() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext0 = new IOContext(bufferRecycler0, jsonEncoding0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
byte[] byteArray0 = iOContext1.allocWriteEncodingBuffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar("'null', 'true', 'false' or NaN", jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('\'', char0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("'null', 'true', 'false' or NaN");
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter(116);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals("null", stringWriter0.toString());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(4, int0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser0.finishToken();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int1 = readerBasedJsonParser0.getTextLength();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertTrue(int1 == int0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(4, int1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test089() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 73, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
try {
readerBasedJsonParser0.getTextLength();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test090() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "' (code 0x", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNull(string0);
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);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertEquals(1, int0);
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);
String string1 = readerBasedJsonParser0.nextFieldName();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNull(string1);
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);
}
@Test(timeout = 4000)
public void test091() throws Throwable {
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'z';
charArray0[1] = 'z';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 33, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'z', 'z', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 7
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test092() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("zF_Ee");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 278, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(278, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("Mv@Y*");
assertEquals("Mv@Y*", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("Mv@Y*", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'zF_Ee': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test093() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("XLD");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("kT8W<k`Y<F[r.61#~");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[25];
charArray0[0] = '*';
charArray0[1] = '`';
charArray0[2] = '!';
charArray0[3] = '+';
charArray0[4] = ';';
charArray0[5] = 'G';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 2876, 2876, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(25, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)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);
assertEquals(25, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'kT8W': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test094() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("kN%/]{ +r");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'kN': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test095() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2000, byteArray0.length);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
byte[] byteArray1 = iOContext0.allocReadIOBuffer(0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(byteArray1, byteArray0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(8000, byteArray1.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext2.allocTokenBuffer();
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 34, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 93, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(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(4000, charArray0.length);
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
try {
readerBasedJsonParser0._handleApos();
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: 187]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test096() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
StringReader stringReader0 = new StringReader("3.0.fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
try {
readerBasedJsonParser0.nextLongValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test097() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("9E1,Ig");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "z");
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 56, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(56, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test098() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'w';
charArray0[1] = '=';
charArray0[3] = 'n';
charArray0[4] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1990), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1990), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue((-1990));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('P' (code 80)) in numeric value: Exponent indicator not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test099() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("+z");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '4';
charArray0[1] = 'E';
charArray0[2] = '4';
charArray0[3] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 119, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', 'E', '4', '4'}, charArray0);
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);
assertEquals(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 4
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test100() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 684, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = '}';
charArray0[1] = 'W';
charArray0[2] = 'Y';
charArray0[3] = '6';
charArray0[4] = '9';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 248, 0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'}', 'W', 'Y', '6', '9'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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);
SerializedString serializedString0 = new SerializedString("z,T:S%d>");
assertEquals(8, serializedString0.charLength());
assertEquals("z,T:S%d>", serializedString0.toString());
assertEquals("z,T:S%d>", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("");
assertEquals(0, serializedString1.charLength());
assertEquals("", serializedString1.getValue());
assertEquals("", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, serializedString1.charLength());
assertEquals("", serializedString1.getValue());
assertEquals("", serializedString1.toString());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(serializedString1, serializedString0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(serializedString1.equals((Object)serializedString0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(boolean0);
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);
char[] charArray1 = readerBasedJsonParser1.getTextCharacters();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(charArray1);
assertArrayEquals(new char[] {'}', 'W', 'Y', '6', '9'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser1._matchToken("z,T:S%d>", 494);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test101() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, false, false);
assertFalse(boolean0);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1369, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1369, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Boolean boolean2 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1369, readerBasedJsonParser0.getFeatureMask());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(boolean2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1369, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: UNKNOWN; line: 1, column: 37]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test102() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2718), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-2718), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-2718), readerBasedJsonParser0.getFeatureMask());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isNaN());
assertNull(boolean0);
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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 28]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test103() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c%'");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 86, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 3, true);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
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(2, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("TYaTI94~^", jsonToken0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals('=', char0);
assertArrayEquals(new char[] {'=', 't'}, charArray0);
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(2, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 239, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
readerBasedJsonParser1.nextToken();
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
char char1 = readerBasedJsonParser0._decodeEscaped();
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(char1 == char0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('\t', char1);
assertArrayEquals(new char[] {'=', 't'}, charArray0);
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(2, charArray0.length);
}
@Test(timeout = 4000)
public void test104() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("t$gxu*'=4v@}rh");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals('\t', char0);
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);
SerializedString serializedString0 = new SerializedString("t$gxu*'=4v@}rh");
assertEquals("t$gxu*'=4v@}rh", serializedString0.toString());
assertEquals("t$gxu*'=4v@}rh", serializedString0.getValue());
assertEquals(14, serializedString0.charLength());
assertNotNull(serializedString0);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test105() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
String string0 = "yP2i:O/iXzcGP";
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 256, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 16, (-3525), true);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(256, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0.getNextChar("yP2i:O/iXzcGP");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read -3525
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test106() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, jsonEncoding0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
byte[] byteArray0 = iOContext1.allocWriteEncodingBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar("'null', 'true', 'false' or NaN", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('\'', char0);
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);
SerializedString serializedString0 = new SerializedString("'null', 'true', 'false' or NaN");
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean0);
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);
StringWriter stringWriter0 = new StringWriter(116);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals("null", stringWriter0.toString());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(4, int0);
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);
String string0 = readerBasedJsonParser0._parseAposName();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
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);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized character escape ',' (code 44)
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test107() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(115);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertSame(iOContext0, iOContext1);
assertNotNull(textBuffer0);
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);
int int0 = readerBasedJsonParser0.nextIntValue(3387);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(9, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(3387, int0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._handleInvalidNumberStart(121, true);
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: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test108() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(274);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{.rZ)M");
assertNotNull(stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(boolean1);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test109() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{<R");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(46);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.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(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(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);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertEquals(1, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertEquals("{", jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(JsonToken.START_OBJECT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(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);
char[] charArray0 = new char[4];
charArray0[0] = '\\';
charArray0[1] = '[';
charArray0[2] = '7';
charArray0[3] = '7';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 35, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 33, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(35, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\', '[', '7', '7'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(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(4, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('<' (code 60)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test110() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
String string0 = "nuSY array";
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2049);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("nuSY array");
assertNotNull(stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nuSY': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test111() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader(",yC");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 670, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(670, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(670, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
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);
try {
readerBasedJsonParser0._finishString();
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test112() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4868, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
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(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(4868, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(4868, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test113() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 791, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(791, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(791, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
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(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test114() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(274);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{.rZ)M");
assertNotNull(stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(boolean0);
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);
StringReader stringReader1 = new StringReader("_wgPsx9i");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("null array");
assertEquals("null array", serializedString0.getValue());
assertEquals("null array", serializedString0.toString());
assertEquals(10, serializedString0.charLength());
assertNotNull(serializedString0);
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test115() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("{.rZ)M");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(37);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(boolean0);
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);
StringReader stringReader1 = new StringReader("{.rZ)M");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("{.rZ)M");
assertEquals("{.rZ)M", serializedString0.getValue());
assertEquals(6, serializedString0.charLength());
assertEquals("{.rZ)M", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("{.rZ)M");
assertEquals("{.rZ)M", serializedString1.getValue());
assertEquals(6, serializedString1.charLength());
assertEquals("{.rZ)M", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test116() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-Infinity", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, (-913), true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
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: UNKNOWN; line: 1, column: -902]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test117() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = 'V';
charArray0[1] = 'K';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 33, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'V', 'K'}, charArray0);
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(2, charArray0.length);
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: UNKNOWN; line: 1, column: 40]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test118() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler1, "CR(6z1{?oz`^ZRS\"j", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader(">_`4inNE4i;mvqIh\"NA");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1978), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals((-1978), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
SerializedString serializedString0 = new SerializedString("CR(6z1{?oz`^ZRS\"j");
assertEquals("CR(6z1{?oz`^ZRS\"j", serializedString0.getValue());
assertEquals("CR(6z1{?oz`^ZRS\"j", serializedString0.toString());
assertEquals(17, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: (String)\"CR(6z1{?oz`^ZRS\"j\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test119() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("LTaN]=*8");
assertNotNull(stringReader0);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1686, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1639, 1, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1686, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
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 test120() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("6lff8@9I");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
// 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 test121() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getInputSource();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(object0, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 2, 348, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser1._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 test122() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
char[] charArray0 = new char[3];
charArray0[0] = '#';
charArray0[1] = '3';
charArray0[2] = 'e';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 116, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 44, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'#', '3', 'e'}, charArray0);
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);
assertEquals(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test123() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1375);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1375, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1375, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
long long0 = readerBasedJsonParser0.nextLongValue((-1458L));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1375, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals((-1458L), long0);
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);
}
@Test(timeout = 4000)
public void test124() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1606), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1606), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1606), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string1 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1606), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("NaN", string1);
assertNotNull(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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1606), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getTextOffset();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1606), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test125() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 684, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(684, readerBasedJsonParser0.getFeatureMask());
assertEquals("", stringWriter0.toString());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, int0);
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);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(200, (String) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input within/between root entries
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test126() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 236, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(236, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
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(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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(236, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(string0);
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(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);
int int0 = readerBasedJsonParser0.nextIntValue((-1033));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(236, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals((-1033), int0);
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(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);
}
@Test(timeout = 4000)
public void test127() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, 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);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF8;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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);
byte[] byteArray0 = iOContext2.allocWriteEncodingBuffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("Non-standaLd token '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 118, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 2322, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
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.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(118, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
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 test128() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("?_");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext1 = new IOContext(bufferRecycler1, "?_", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1211, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 56, 299, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1211, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(4000, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 304]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test129() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
Integer integer0 = new Integer(1891);
assertEquals(1891, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(object0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(94);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = 'w';
charArray0[1] = 'w';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 94, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 3, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(94, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'w', 'w'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(2, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._handleOddName(117);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test130() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+I$T", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+I$T");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
StringReader stringReader1 = new StringReader("+I$T");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2053), stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 2836, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2053), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
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(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(2836);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test131() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("{)xOk");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(0);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(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(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[1];
charArray0[0] = 'e';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1587), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, (-1587), false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-1587), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'e'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-1587), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'3'}, charArray0);
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);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test132() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1953), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-1953), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-1953), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'3'}, charArray0);
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);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test133() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("})m-$,5}'_R[YE9(");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, jsonEncoding0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 35, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker '}': expected ']' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test134() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "TYaTI94~^";
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("}D BySzI'");
assertNotNull(stringReader0);
String string1 = "";
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("}D BySzI'");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker '}': expected ']' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test135() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, "+INF", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(42);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 33, 3, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0._parsePosNumber((-2888));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test136() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{<R");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(46);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
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));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertEquals("{", jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertEquals(1, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.START_OBJECT, jsonToken0);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, ") not VALUE_STRING, can not access as binary", true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
StringReader stringReader1 = new StringReader("{<R");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[6];
charArray0[0] = ',';
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
charArray0[1] = 'X';
charArray0[2] = '\"';
charArray0[3] = '[';
charArray0[4] = 'W';
charArray0[5] = 'o';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1228, 91, false);
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {',', 'X', '\"', '[', 'W', 'o'}, charArray0);
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);
assertEquals(6, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
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(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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);
try {
readerBasedJsonParser0.nextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('<' (code 60)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test137() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("<iHO8HZYR79)}}1s[B");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 119, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(119, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test138() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader2 = new StringReader("-Infinity");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("layRqWJb");
assertEquals("layRqWJb", serializedString0.toString());
assertEquals("layRqWJb", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test139() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, "0", false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader1 = new StringReader("0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4171), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-4171), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-4171), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader2 = new StringReader("MIME-NO-LINEFEEDS");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-4171), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader2);
assertNotSame(stringReader1, stringReader0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(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(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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 44, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(44, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('M' (code 77)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test140() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(248);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("gW");
assertNotNull(stringReader0);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer((-2274));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader1 = new StringReader("Unexpected end of base64-encoded String: base64 variant '%s' expects padding (one or more '%c' characters) at the end");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(225);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2274), stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 2113, 73, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-2274), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0._handleOddValue(2113);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 73
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test141() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = 'v';
charArray0[1] = ' ';
charArray0[2] = 'v';
charArray0[3] = 'v';
charArray0[4] = 'v';
charArray0[5] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-873), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 5, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-873), readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'v', ' ', 'v', 'v', 'v', 'v'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(6, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-873), readerBasedJsonParser0.getFeatureMask());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'v', ' ', 'v', 'v', 'v', 'v'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(6, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertEquals(1, BufferRecycler.CHAR_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);
readerBasedJsonParser1.nextToken();
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertTrue(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)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);
System.setCurrentTimeMillis((-2147483648L));
try {
readerBasedJsonParser0._finishString2();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test142() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "IU!|dY", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextLongValue(0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token 'NaN': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test143() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(6);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token 'NaN': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test144() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-3380), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser0._matchToken("0123456789ABCDEF", 0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: (StringReader); line: 1, column: 49]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test145() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, (-2570), false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
int int0 = 328;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 328, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 0, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(328, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser1._parseNegNumber();
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 test146() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '5';
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '5';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 0, 34, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'5'}, charArray1);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray1.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertArrayEquals(new char[] {'5'}, charArray1);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray1.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextValue();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test147() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = iOContext0.withEncoding((JsonEncoding) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader2 = new StringReader("No Base64Variant with name ");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertNull(string0);
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);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test148() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
charArray0[4] = 'i';
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(699);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 122, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, 1, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(122, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', 'i'}, charArray0);
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);
assertEquals(5, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(122, readerBasedJsonParser0.getFeatureMask());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l', ' '}, charArray0);
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);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(2);
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isNumeric());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(122, readerBasedJsonParser0.getFeatureMask());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l', ' '}, charArray0);
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);
assertEquals(5, charArray0.length);
}
@Test(timeout = 4000)
public void test149() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("h%ZjM_^!rQQ8+]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(1548);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(charArray0);
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(1548, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'h': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test150() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("hY");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "|K+MBSh~y$BxvQ\"oJ0R*", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertEquals("expected a valid value (number, String, array, object, 'true', 'false' or 'null')", serializedString0.toString());
assertEquals(81, serializedString0.charLength());
assertEquals("expected a valid value (number, String, array, object, 'true', 'false' or 'null')", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'hY': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test151() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("}D BySzI'");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
SerializedString serializedString0 = new SerializedString("TYaTI94~^");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~^", serializedString0.toString());
assertEquals("TYaTI94~^", serializedString0.getValue());
assertNotNull(serializedString0);
char[] charArray0 = new char[3];
charArray0[0] = '@';
charArray0[1] = '\\';
charArray0[2] = 'Q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-390), (-390), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'@', '\\', 'Q'}, charArray0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
SerializedString serializedString1 = new SerializedString("");
assertEquals(0, serializedString1.charLength());
assertEquals("", serializedString1.getValue());
assertEquals("", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker '}': expected ']' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: -388]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test152() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
SerializedString serializedString0 = new SerializedString("]*4McxEz8f");
assertEquals("]*4McxEz8f", serializedString0.getValue());
assertEquals(10, serializedString0.charLength());
assertEquals("]*4McxEz8f", serializedString0.toString());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("]*4McxEz8f");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 120, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(120, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getInputSource();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(120, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader1, object0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(object0, stringReader0);
assertSame(object0, stringReader1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(120, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object0.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test153() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
SerializedString serializedString0 = new SerializedString("]*4McxEz8f");
assertEquals("]*4McxEz8f", serializedString0.toString());
assertEquals(10, serializedString0.charLength());
assertEquals("]*4McxEz8f", serializedString0.getValue());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("]*4McxEz8f");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 120, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(120, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(248);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test154() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("]*4McxEz8f");
assertEquals("]*4McxEz8f", serializedString0.toString());
assertEquals("]*4McxEz8f", serializedString0.getValue());
assertEquals(10, serializedString0.charLength());
assertNotNull(serializedString0);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2087), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals((-2087), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
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); line: 1, column: 0])
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test155() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^dH_]K7;epo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 498, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, (-1332), 117, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(498, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._loadMoreGuaranteed();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test156() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("}D BySzI'");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, "", false);
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker '}': expected ']' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test157() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "}D BySzI'";
StringReader stringReader0 = new StringReader("}D BySzI'");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3877, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3877, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0.nextLongValue(859L);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker '}': expected ']' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test158() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'C';
charArray0[1] = '^';
charArray0[2] = '\"';
charArray0[3] = ':';
charArray0[4] = '_';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3588, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 32768, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3588, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'C', '^', '\"', ':', '_'}, charArray0);
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(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(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test159() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
int int0 = stringReader0.read();
assertEquals(84, int0);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 69, stringReader0, objectCodec1, charsToNameCanonicalizer2, charArray0, 0, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(69, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0._parseName();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(69, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
}
@Test(timeout = 4000)
public void test160() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("5e?{/C\"=(");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2708), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-2708), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('?' (code 63)) in numeric value: Exponent indicator not followed by a digit
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test161() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'w';
charArray0[1] = '=';
charArray0[2] = ' ';
charArray0[3] = 'n';
charArray0[4] = 'M';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 248, 248, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'w', '=', ' ', 'n', 'M'}, charArray0);
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);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('P' (code 80)) in numeric value: Exponent indicator not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 252]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test162() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3EP~4P6P:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[0] = 'M';
charArray0[1] = 'n';
charArray0[2] = 'M';
charArray0[3] = 'w';
charArray0[4] = 'w';
charArray0[5] = 'R';
charArray0[6] = '=';
charArray0[5] = 'n';
charArray0[8] = 'w';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2483, 1, false);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'M', 'n', 'M', 'w', 'w', 'n', '=', '\u0000', 'w'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(9, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('P' (code 80)) in numeric value: Exponent indicator not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test163() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("bC29ME|BFYk");
assertNotNull(stringReader0);
stringReader0.reset();
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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 charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2000, 2000, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
TypeReference<String> typeReference0 = (TypeReference<String>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Integer integer0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(integer0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 243, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(243, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
StringReader stringReader1 = new StringReader("bC29ME|BFYk");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'bC29ME': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test164() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("bwR9>xeb~");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(15);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.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(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-175), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-175), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'bwR9': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test165() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding((JsonEncoding) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
StringReader stringReader1 = new StringReader("&Afvthf");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 24, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0.finishToken();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(41);
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, objectCodec1, charsToNameCanonicalizer3, charArray0, 0, 1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(123, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser1._finishString2();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(123, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertArrayEquals(new char[] {'\"'}, charArray0);
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);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test166() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
char[] charArray0 = new char[3];
charArray0[0] = 'D';
charArray0[1] = 'D';
charArray0[2] = 'w';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 34, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1079), 3, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D', 'D', 'w'}, charArray0);
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(3, charArray0.length);
StringReader stringReader1 = new StringReader("'hm");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1841), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 43, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals((-1841), readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'D', 'D', 'w'}, charArray0);
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(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._handleOddName(116);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 33
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test167() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
assertEquals(1, BufferRecycler.CHAR_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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
assertEquals(1, BufferRecycler.CHAR_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);
byte[] byteArray0 = iOContext2.allocWriteEncodingBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(byteArray0);
assertEquals(1, BufferRecycler.CHAR_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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("Non-standard token '");
assertNotNull(stringReader0);
System.setCurrentTimeMillis(2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(3, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1290, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2133), 2, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(3, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1290, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(200, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(49);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2133
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test168() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3729), stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-3729), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = 'h';
charArray0[1] = 'v';
charArray0[2] = 'S';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 456, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 3743, false);
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(456, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'h', 'v', 'S'}, charArray0);
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);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_ARRAY;
char char0 = readerBasedJsonParser1.getNextChar("p", jsonToken0);
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(456, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals('v', char0);
assertArrayEquals(new char[] {'h', 'v', 'S'}, charArray0);
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);
assertEquals(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
stringReader1.mark(3743);
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(10, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.currentToken());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-3729), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(boolean0);
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);
// Undeclared exception!
try {
readerBasedJsonParser1._finishString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test169() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "TYaTI94~ ", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("fGsHS.s<t*u2<yb]X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(89);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 645, 1, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser1._loadMore();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test170() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTIY4~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 2, (-2), 0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor0);
assertNotNull(mockFileOutputStream0);
try {
readerBasedJsonParser0.readBinaryValue((Base64Variant) null, (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: UNKNOWN; line: 1, column: 34]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test171() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.%BGs.|SSddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 73, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals('q', char0);
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);
String string0 = readerBasedJsonParser0.getValueAsString("qn/.%BGs.|SSddZ");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals("qn/.%BGs.|SSddZ", string0);
assertNotNull(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'q';
charArray0[1] = 'q';
charArray0[2] = 'q';
charArray0[3] = 'q';
charArray0[4] = 'q';
charArray0[5] = 'q';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 256, 256, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'q', 'q', 'q', 'q', 'q', 'q', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, (-2892), stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray0, 123, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.currentToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals((-2892), readerBasedJsonParser2.getFeatureMask());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {'q', 'q', 'q', 'q', 'q', 'q', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextIntValue(2);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test172() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1239, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1239, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test173() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 432, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
FileDescriptor fileDescriptor1 = new FileDescriptor();
assertFalse(fileDescriptor1.valid());
assertFalse(fileDescriptor1.equals((Object)fileDescriptor0));
assertNotNull(fileDescriptor1);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor1);
assertFalse(fileDescriptor1.equals((Object)fileDescriptor0));
assertNotNull(mockFileOutputStream0);
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: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test174() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '4';
charArray0[1] = '4';
charArray0[3] = '\"';
charArray0[4] = 'v';
charArray0[5] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 272, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '4', '\u0000', '\"', 'v', '4', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'D', 'V', 'K', '_', '\'', 'O', '|'}, charArray0);
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);
assertEquals(7, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(108);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
charsToNameCanonicalizer2.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer2);
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
MockFile mockFile0 = new MockFile("DVK_'O|6fg_87");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) "DVK_'O|6fg_87");
assertEquals(14L, mockFile0.length());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.canExecute());
assertEquals("DVK_'O|6fg_87", mockFile0.toString());
assertEquals(0L, mockFile0.getTotalSpace());
assertTrue(mockFile0.exists());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals("DVK_'O|6fg_87", mockFile0.getName());
assertFalse(mockFile0.isAbsolute());
assertFalse(mockFile0.isDirectory());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.getUsableSpace());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isHidden());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
try {
readerBasedJsonParser1.readBinaryValue((OutputStream) printStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test175() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("Illegal character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("l4fV-0bO`5X[y2h`S");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader2 = new StringReader("*:~%**^a$MF>p6U)");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('l' (code 108)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test176() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+I$F", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+I$F");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[1] = 'P';
charArray0[2] = 'x';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 91, 3, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'P', 'x'}, charArray0);
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);
assertEquals(3, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'+', 'I', '$'}, charArray0);
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);
assertEquals(3, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('$' (code 36)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test177() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 432, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("-INF");
assertEquals("-INF", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertEquals("-INF", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean1 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals("-INF", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertEquals("-INF", serializedString0.getValue());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
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);
// Undeclared exception!
try {
charsToNameCanonicalizer1.makeChild(162);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test178() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(1282);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJR*");
assertNotNull(stringReader0);
char[] charArray0 = new char[7];
charArray0[0] = 'h';
charArray0[1] = '4';
charArray0[2] = '\'';
charArray0[3] = '&';
charArray0[4] = 'Y';
charArray0[5] = '4';
charArray0[6] = 'U';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1, 4055, false);
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'h', '4', '\'', '&', 'Y', '4', 'U'}, charArray0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (''' (code 39)): 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 test179() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (cod]e 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(114);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = (-1104);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[3];
charArray0[0] = '!';
charArray0[1] = 'l';
charArray0[2] = 'i';
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1104), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1104), 0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-1104), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'!', 'l', 'i'}, charArray0);
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(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddValue(110);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1104
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test180() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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();
StringReader stringReader0 = new StringReader(" -- suspect a DoS attack based on hash collisions");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("TYaTI94~ ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = 'Z';
charArray0[1] = 'G';
charArray0[2] = '}';
charArray0[3] = 'T';
charArray0[4] = 'p';
charArray0[5] = 'b';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-649), stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 33, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-649), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'Z', 'G', '}', 'T', 'p', 'b'}, charArray0);
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(6, charArray0.length);
Class<String> class0 = String.class;
String string0 = readerBasedJsonParser0.readValueAs(class0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-649), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertArrayEquals(new char[] {'Z', 'G', '}', 'T', 'p', 'b'}, charArray0);
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(6, charArray0.length);
IOContext iOContext1 = new IOContext((BufferRecycler) null, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
int int0 = (-3380);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 121, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(121, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('-' (code 45)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test181() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 54, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 50, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(54, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'1'}, charArray0);
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);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser0._handleOddValue(93);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (']' (code 93)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 51]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test182() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, jsonEncoding0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("3.0fl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {']'}, charArray0);
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(1, charArray0.length);
try {
readerBasedJsonParser0._handleOddValue(93);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (']' (code 93)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test183() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "SZ5s~.ewygeM*~x,", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(byteArray1, byteArray0);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(8000, byteArray1.length);
charArray0[0] = 'r';
charArray0[1] = '^';
charArray0[2] = '!';
charArray0[3] = 'R';
charArray0[4] = 'N';
charArray0[5] = '2';
charArray0[6] = '0';
charArray0[7] = 'X';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 2388, true);
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'r', '^', '!', 'R', 'N', '2', '0', 'X'}, charArray0);
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);
assertEquals(8, 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: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test184() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertEquals('\'', char0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = ' ';
charArray0[1] = '\"';
charArray0[2] = '*';
charArray0[3] = 'v';
charArray0[4] = '*';
charArray0[5] = 'v';
boolean boolean1 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "J{");
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 32, 2, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {' ', '\"', '*', 'v', '*', 'v'}, charArray0);
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);
assertEquals(6, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextTextValue();
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test185() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler1, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4309, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1816, 92, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(4309, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(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(0, charArray0.length);
readerBasedJsonParser0._releaseBuffers();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(4309, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertArrayEquals(new char[] {}, charArray0);
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(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(0, charArray0.length);
try {
readerBasedJsonParser0.nextIntValue(33);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 92
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test186() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, "+Infinity", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("H#7");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = ']';
charArray0[1] = 'v';
charArray0[2] = ' ';
charArray0[3] = 'w';
charArray0[4] = '*';
charArray0[5] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 61, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 102, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(61, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {']', 'v', ' ', 'w', '*', '\"'}, charArray0);
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(6, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test187() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer1.makeChild(119);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test188() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer((-2));
assertEquals((-2), (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, "]DBtb", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("]DBtb");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2006, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2006, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2006, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected close marker ']': expected '}' (for root starting at [Source: UNKNOWN; line: 1, column: 0])
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test189() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer((-2274));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("Unexpected end of base64-encoded String: base64 variant '%s' expects padding (one or more '%c' characters) at the end");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(225);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
Object object1 = readerBasedJsonParser0.getInputSource();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertSame(stringReader0, object1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertSame(object1, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(object1);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertSame(stringReader0, object1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNull(string0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer1.makeChild(10);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 248, stringReader0, objectCodec1, charsToNameCanonicalizer3, (char[]) null, 0, 248, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(248, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Unexpected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test190() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Unexpected character (%s) in numeric value");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(53);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler1, integer0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("4m)+pC");
assertEquals(6, serializedString0.charLength());
assertEquals("4m)+pC", serializedString0.getValue());
assertEquals("4m)+pC", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Unexpected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test191() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "TYaTI94~^";
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_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);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertNotNull(stringReader0);
char[] charArray1 = new char[2];
assertFalse(charArray1.equals((Object)charArray0));
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 33, 3, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray1);
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);
assertEquals(2, charArray1.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
String string1 = "?{M|Z6)tJkr";
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("?{M|Z6)tJkr", jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(charArray1, charArray0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charArray1.equals((Object)charArray0));
assertEquals('=', char0);
assertArrayEquals(new char[] {'=', 't'}, charArray1);
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);
assertEquals(2, charArray1.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextToken();
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test192() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("J_OU2EdYta");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[2] = '[';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 13, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(jsonToken0.isScalarValue());
assertEquals("[", jsonToken0.asString());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals(3, jsonToken0.id());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(integer0.equals((Object)int0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("[", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
int int1 = readerBasedJsonParser0.getTextOffset();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertTrue(int1 == int0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(integer0.equals((Object)int0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(integer0.equals((Object)int0));
assertFalse(integer0.equals((Object)int1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean0);
assertArrayEquals(new char[] {'J', '_', 'O'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test193() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
assertEquals(1, BufferRecycler.CHAR_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(8000, byteArray0.length);
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertEquals(9, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertEquals(9, serializedString1.charLength());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(serializedString1, serializedString0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(7, charArray0.length);
try {
readerBasedJsonParser0.getTextCharacters();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: was expecting closing quote for a string value
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 14]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test194() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("vRdaYKz&kv");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 625, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(625, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(625, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals('v', char0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'RdaYKz': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test195() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[0] = 'm';
charArray0[1] = ']';
charArray0[2] = '1';
charArray0[3] = '>';
charArray0[4] = '{';
charArray0[5] = '+';
charArray0[6] = '{';
charArray0[7] = ',';
charArray0[8] = 'T';
int int0 = stringReader0.read(charArray0, 0, 2);
assertEquals(2, int0);
assertArrayEquals(new char[] {'1', '/', '1', '>', '{', '+', '{', ',', 'T'}, charArray0);
assertEquals(9, charArray0.length);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'RQ': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test196() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 2, 0, 3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(200);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("expected padding character '");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[9];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[1] = '(';
charArray1[2] = '(';
charArray1[5] = '(';
charArray1[7] = '(';
charArray1[8] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4658), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray1, 0, (-9), true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-4658), readerBasedJsonParser0.getFeatureMask());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '(', '(', '\u0000', '\u0000', '(', '\u0000', '(', '('}, charArray1);
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);
assertEquals(9, charArray1.length);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(87, " in a Number value");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('p' (code 112)): was expecting a colon to separate field name and value
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test197() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader(";L$qZ7");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(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);
stringReader0.close();
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(3);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)43;
byteArray0[1] = (byte)73;
byteArray0[3] = (byte)43;
byteArray0[4] = (byte)43;
byteArray0[5] = (byte)43;
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test198() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "SZ5s~.ewygeM*~x,", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(73);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("1/RQ=|");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-86), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-86), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('/' (code 47)): Expected space separating root-level values
// at [Source: (String)\"SZ5s~.ewygeM*~x,\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test199() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals(9, serializedString0.charLength());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString1.charLength());
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
int int0 = serializedString1.appendQuoted(charArray0, 3);
assertEquals(9, serializedString1.charLength());
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertNotSame(serializedString1, serializedString0);
assertTrue(serializedString1.equals((Object)serializedString0));
assertEquals((-1), int0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertEquals(9, serializedString1.charLength());
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(serializedString1, serializedString0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(2, jsonLocation0.getLineNr());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
JsonLocation jsonLocation1 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, jsonLocation1.getLineNr());
assertEquals((-1L), jsonLocation1.getByteOffset());
assertEquals(1L, jsonLocation1.getCharOffset());
assertEquals(2, jsonLocation1.getColumnNr());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonLocation1, jsonLocation0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(jsonLocation1.equals((Object)jsonLocation0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation1);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
}
@Test(timeout = 4000)
public void test200() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "yP2i:O/iXzcGP";
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.reset();
StringReader stringReader1 = new StringReader("ifQnFN");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = stringReader0.ready();
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertTrue(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1950, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1950, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ifQnFN': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test201() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("iDIu,yn#@lx[");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(89);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'iDIu': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test202() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-1062), 85, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'v'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(85);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1062), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals((-1062), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('A' (code 65)): Expected space separating root-level values
// at [Source: (String)\"TYaTI94~ \"; line: 1, column: 12]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test203() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = '+';
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1969, 3, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'+', '4'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
Object object0 = readerBasedJsonParser0.getTypeId();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
assertArrayEquals(new char[] {'+', '4'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-2497), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals((-2497), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test204() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader(",yC");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader(">");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext0 = new IOContext(bufferRecycler0, "VALUE_NUMBER_FLOAT", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Object object1 = readerBasedJsonParser0.getTypeId();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler1, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
StringReader stringReader2 = new StringReader(",yC");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
SerializedString serializedString0 = new SerializedString("C7");
assertEquals("C7", serializedString0.getValue());
assertEquals("C7", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): 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 test205() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader(",yC");
assertNotNull(stringReader0);
stringReader0.reset();
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("UTF16_LE");
assertEquals("UTF16_LE", serializedString0.getValue());
assertEquals("UTF16_LE", serializedString0.toString());
assertEquals(8, serializedString0.charLength());
assertNotNull(serializedString0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): 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 test206() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[3] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 200, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals('3', char0);
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);
String string0 = readerBasedJsonParser0.getValueAsString((String) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(string0);
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);
int int0 = readerBasedJsonParser0.getTextOffset();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, 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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.close();
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test207() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
char[] charArray0 = new char[3];
charArray0[0] = 'C';
charArray0[1] = '2';
charArray0[2] = '\'';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 112, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(112, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'C', '2', '\''}, charArray0);
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);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
String string0 = readerBasedJsonParser1.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
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);
try {
readerBasedJsonParser0._reportInvalidToken("", "");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test208() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals(9, serializedString1.charLength());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertEquals("TYaTI94~ ", serializedString1.getValue());
assertEquals(9, serializedString1.charLength());
assertEquals("TYaTI94~ ", serializedString1.toString());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(serializedString1, serializedString0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0.nextLongValue(0L);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: was expecting closing quote for a string value
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 14]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test209() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertNotNull(stringReader0);
char[] charArray1 = new char[2];
assertFalse(charArray1.equals((Object)charArray0));
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 97, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 33, 3, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray1.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("?{M|Z6)tJkr", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(charArray1, charArray0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(charArray1.equals((Object)charArray0));
assertEquals('=', char0);
assertArrayEquals(new char[] {'=', 't'}, charArray1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray1.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 239, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser1.nextToken();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertTrue(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser1.getTextOffset();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertTrue(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextLongValue(1L);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test210() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("t");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(57);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 't': 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 test211() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = 'N';
charArray0[2] = 'N';
charArray0[3] = '1';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[5] = 'N';
charArray0[6] = 'N';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 91, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', 'N', 'N', '1', '\u0000', 'N', 'N'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', 'N', 'N', '1', '\u0000', 'N', 'N'}, charArray0);
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(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 0)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test212() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("5e?{/C\"=(");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2708), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-2708), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('?' (code 63)) in numeric value: Exponent indicator not followed by a digit
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test213() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[1] = 'g';
charArray0[2] = '\\';
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 120, 3, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'g', '\\'}, charArray0);
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(3, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
char char0 = readerBasedJsonParser0.getNextChar("-4.Jtg", jsonToken0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('-', char0);
assertArrayEquals(new char[] {'-', '4', '.'}, charArray0);
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(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("-4.Jtg");
assertEquals(6, serializedString0.charLength());
assertEquals("-4.Jtg", serializedString0.getValue());
assertEquals("-4.Jtg", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test214() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn<.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = '7';
charArray0[3] = 'n';
charArray0[5] = 't';
charArray0[3] = 'N';
charArray0[4] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'7', '\u0000', '\u0000', 'N', '1', 't'}, charArray0);
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);
assertEquals(6, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'q', 'n', '<', '.', 'B', 'G'}, charArray0);
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);
assertEquals(6, charArray0.length);
int int0 = 817;
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
int int1 = (-1700);
boolean boolean0 = false;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, (-1700), false);
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'q', 'n', '<', '.', 'B', 'G'}, charArray0);
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);
assertEquals(6, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 's': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -1698]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test215() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("[G+\r]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
int int0 = stringReader0.read();
assertEquals(91, int0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 165, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(165, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'G': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test216() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1114111, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
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);
stringReader0.reset();
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(string0);
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);
try {
readerBasedJsonParser0._handleOddValue((-886));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: 29]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test217() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_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);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 97, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 3, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
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(2, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("?{M|Z6)tJkr", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals('=', char0);
assertArrayEquals(new char[] {'=', 't'}, charArray0);
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(2, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 239, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
readerBasedJsonParser1.nextToken();
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertTrue(readerBasedJsonParser1.isClosed());
assertEquals(239, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
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);
}
@Test(timeout = 4000)
public void test218() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 33, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 1, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
try {
readerBasedJsonParser0._loadMoreGuaranteed();
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 test219() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("IL;zO*`P3f");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = 'l';
charArray0[1] = '-';
charArray0[2] = ' ';
charArray0[3] = '#';
charArray0[4] = 'W';
charArray0[5] = 'W';
charArray0[6] = 'Z';
charArray0[7] = 'i';
charArray0[8] = 'M';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 14, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'l', '-', ' ', '#', 'W', 'W', 'Z', 'i', 'M'}, charArray0);
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);
assertEquals(9, charArray0.length);
readerBasedJsonParser0._loadMoreGuaranteed();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertArrayEquals(new char[] {'I', 'L', ';', 'z', 'O', '*', '`', 'P', '3'}, charArray0);
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);
assertEquals(9, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 14]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test220() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 58, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(58, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(123);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-2035));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)84;
byteArray0[1] = (byte) (-13);
byteArray0[2] = (byte) (-93);
byteArray0[3] = (byte)73;
byteArray0[4] = (byte) (-13);
byteArray0[5] = (byte)43;
byteArray0[6] = (byte) (-13);
byteArray0[7] = (byte)73;
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArray0);
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test221() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader(" -- suspect a DoS attack based on hash collisions");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("w");
assertEquals(1, serializedString0.charLength());
assertEquals("w", serializedString0.getValue());
assertEquals("w", serializedString0.toString());
assertNotNull(serializedString0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = '|';
charArray0[1] = 'N';
charArray0[2] = ']';
charArray0[3] = '=';
charArray0[4] = '\'';
charArray0[5] = 'D';
charArray0[6] = 'D';
charArray0[7] = 'D';
charArray0[8] = 'L';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 106, stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray0, (-1396), 0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(106, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'|', 'N', ']', '=', '\'', 'D', 'D', 'D', 'L'}, charArray0);
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);
assertEquals(9, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(106, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-1396L), jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1395), jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertArrayEquals(new char[] {'|', 'N', ']', '=', '\'', 'D', 'D', 'D', 'L'}, charArray0);
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);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(9, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2959, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(2959, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = readerBasedJsonParser1._loadMore();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(2959, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test222() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+INF", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = '`';
charArray0[1] = 'P';
StringReader stringReader1 = new StringReader("48#*e[@8");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', 'P', '\u0000'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'`', 'P', '\u0000'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 144, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(144, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser1.getNextChar("48#*e[@8");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(144, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('4', char0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("48#*e[@8");
assertEquals("48#*e[@8", serializedString0.toString());
assertEquals(8, serializedString0.charLength());
assertEquals("48#*e[@8", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('#' (code 35)): 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 test223() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("8x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("8x");
assertEquals("8x", serializedString0.toString());
assertEquals("8x", serializedString0.getValue());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('x' (code 120)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test224() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "Leading zeroes not allowed");
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertEquals('\'', char0);
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);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean2 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertSame(iOContext0, iOContext1);
assertTrue(boolean2 == boolean1);
assertTrue(boolean2 == boolean0);
assertFalse(boolean2);
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);
BufferRecycler bufferRecycler1 = null;
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringWriter stringWriter0 = new StringWriter(1);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringWriter stringWriter1 = stringWriter0.append((CharSequence) "");
assertEquals("", stringWriter0.toString());
assertEquals("", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertNotNull(stringWriter1);
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotNull(charArray0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l'}, charArray0);
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(4, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(5L, jsonLocation0.getCharOffset());
assertEquals(6, jsonLocation0.getColumnNr());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotNull(jsonLocation0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter1);
assertEquals("null", stringWriter0.toString());
assertEquals("null", stringWriter1.toString());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertSame(iOContext0, iOContext1);
assertEquals(4, int0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = null;
try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-1428), stringReader0, objectCodec1, 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 test225() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
Integer integer0 = new Integer(6);
assertEquals(6, (int)integer0);
assertNotNull(integer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn(integer0).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn("expected a valid value (number, String, array, object, 'true', 'false' or 'null')").when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '';
charArray0[1] = 'Z';
charArray0[3] = 'V';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3030, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 116, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(6, object0);
assertNotNull(object0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals('', char0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertEquals(81, serializedString0.charLength());
assertEquals("expected a valid value (number, String, array, object, 'true', 'false' or 'null')", serializedString0.toString());
assertEquals("expected a valid value (number, String, array, object, 'true', 'false' or 'null')", serializedString0.getValue());
assertNotNull(serializedString0);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test226() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = new char[8];
charArray0[0] = 'z';
charArray0[1] = ' ';
charArray0[2] = '\"';
charArray0[3] = 'Z';
charArray0[4] = 'H';
charArray0[5] = 'u';
charArray0[6] = '8';
charArray0[7] = ';';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-859), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 53, true);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-859), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'z', ' ', '\"', 'Z', 'H', 'u', '8', ';'}, charArray0);
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);
assertEquals(8, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ZHu8': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test227() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
Integer integer0 = new Integer(6);
assertEquals(6, (int)integer0);
assertNotNull(integer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn(integer0).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn("expected a valid value (number, String, array, object, 'true', 'false' or 'null')").when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '';
charArray0[1] = 'Z';
charArray0[3] = 'V';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3030, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 116, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, object0);
assertNotNull(object0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 116, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser1._handleApos();
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
long long0 = readerBasedJsonParser1.nextLongValue(0L);
assertEquals(58, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(9, readerBasedJsonParser1.currentTokenId());
assertEquals(9, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(57L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0L, long0);
assertArrayEquals(new char[] {'', 'Z', '\u0000', 'V', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
}
@Test(timeout = 4000)
public void test228() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2117));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
charArray0[4] = '4';
charArray0[5] = '\"';
charArray0[6] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 401, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 3, 0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(401, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '4', '\"', '4', '\"', '\"'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(401, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'j', '\"', 's', '#', ',', '_', '_'}, charArray0);
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(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-2298), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals((-2298), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
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);
char char0 = readerBasedJsonParser1.getNextChar("ockDY\"c?");
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals((-2298), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('.', char0);
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);
SerializedString serializedString0 = new SerializedString("s<T`WvQ}");
assertEquals("s<T`WvQ}", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("s<T`WvQ}", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'j': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test229() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'A';
charArray0[1] = 'U';
charArray0[2] = 'U';
charArray0[3] = 'A';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 49, 0, true);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'A', 'U', 'U', 'A'}, charArray0);
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);
assertEquals(4, charArray0.length);
StringReader stringReader1 = new StringReader("fc'1v6[!e");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test230() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(248);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("gW");
assertNotNull(stringReader0);
stringReader0.mark(3);
StringReader stringReader1 = new StringReader("+");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(696);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("Exponent indicator not followed by a digit");
assertEquals("Exponent indicator not followed by a digit", serializedString0.getValue());
assertEquals(42, serializedString0.charLength());
assertEquals("Exponent indicator not followed by a digit", serializedString0.toString());
assertNotNull(serializedString0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a Number value
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test231() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
Integer integer0 = new Integer((-217));
assertEquals((-217), (int)integer0);
assertNotNull(integer0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "W$bRj5=0oHcR,", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '';
charArray0[1] = 'Z';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 47, 0, true);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(2, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-516), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(1, BufferRecycler.CHAR_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);
JsonToken jsonToken0 = readerBasedJsonParser1._handleApos();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
long long0 = readerBasedJsonParser1.nextLongValue(47);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals((-516), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.currentToken());
assertEquals(9, readerBasedJsonParser1.currentTokenId());
assertEquals(9, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(58, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(57L, readerBasedJsonParser1.getTokenCharacterOffset());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(47L, long0);
assertEquals(1, BufferRecycler.CHAR_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);
}
@Test(timeout = 4000)
public void test232() throws Throwable {
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
StringReader stringReader0 = new StringReader("[truncated ");
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();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("*~!#!d.UFIxr[|DZ/|J");
assertEquals("*~!#!d.UFIxr[|DZ/|J", serializedString0.toString());
assertEquals(19, serializedString0.charLength());
assertEquals("*~!#!d.UFIxr[|DZ/|J", serializedString0.getValue());
assertNotNull(serializedString0);
char[] charArray0 = new char[2];
charArray0[0] = 'N';
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
charArray0[1] = 'k';
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-125), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 4, 3, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-125), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', 'k'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-125), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(treeNode0);
assertArrayEquals(new char[] {'N', 'k'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 680, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(680, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
JsonToken jsonToken0 = readerBasedJsonParser1.nextToken();
assertTrue(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(3, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser1.currentToken());
assertEquals(680, readerBasedJsonParser1.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(3, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isStructStart());
assertEquals("[", jsonToken0.asString());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'truncated': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test233() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Numeric value (%s) out of range of int (%d - %s)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(86);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = 'b';
charArray0[1] = '=';
charArray0[2] = '\\';
charArray0[3] = '$';
charArray0[4] = 'b';
charArray0[5] = '(';
charArray0[6] = ',';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 33, false);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'b', '=', '\\', '$', 'b', '(', ','}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0._finishString2();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized character escape '$' (code 36)
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test234() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[0];
int int0 = 1544;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2592, 1544, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(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);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 1544
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test235() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.reset();
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = stringReader0.ready();
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertTrue(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1950, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1950, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0._handleOddName(1685);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1950, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string0);
assertNotNull(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(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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test236() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader(" -- suspect a DoS attack based on hash collisions");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, objectCodec0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'V';
charArray0[1] = '7';
charArray0[2] = 'C';
charArray0[3] = 'r';
charArray0[4] = '3';
charArray0[5] = '9';
charArray0[6] = ',';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-257), stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 1, 2, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-257), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'V', '7', 'C', 'r', '3', '9', ','}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-257), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'V', '7', 'C', 'r', '3', '9', ','}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-257), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {' ', 's', 'u', 's', 'p', 'e', 'c'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, 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: (String)\"TYaTI94~ \"; line: 2, column: 52]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test237() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("`bO|;~/]p");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getInputSource();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(stringReader0, object0);
assertSame(object0, stringReader0);
assertNotNull(object0);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = ' ';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-1528), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, (-1577), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals((-1528), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {' '}, charArray0);
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(1, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('`' (code 96)): 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 test238() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJR*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(1282);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader1 = new StringReader("g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("g");
assertEquals("g", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals("g", serializedString0.toString());
assertNotNull(serializedString0);
char[] charArray0 = new char[8];
charArray0[0] = '&';
charArray0[1] = '#';
charArray0[2] = 'x';
charArray0[3] = '`';
charArray0[4] = 'J';
charArray0[5] = ' ';
charArray0[6] = ',';
charArray0[7] = 'B';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 3, 120, true);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'&', '#', 'x', '`', 'J', ' ', ',', 'B'}, charArray0);
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);
assertEquals(8, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('`' (code 96)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test239() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2117));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
charArray0[4] = '4';
charArray0[5] = '\"';
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._finishString();
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)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);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized character escape 's' (code 115)
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test240() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding((JsonEncoding) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'd';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 15, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 123, 120, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(15, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'d'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec1, charsToNameCanonicalizer2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
readerBasedJsonParser1._finishString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
}
@Test(timeout = 4000)
public void test241() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("-INF");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertNotNull(serializedString0);
char[] charArray0 = new char[7];
charArray0[0] = 'y';
charArray0[1] = '9';
charArray0[2] = 'f';
charArray0[3] = 'D';
charArray0[4] = '\'';
charArray0[5] = ':';
charArray0[6] = '3';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 97, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 2, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'y', '9', 'f', 'D', '\'', ':', '3'}, charArray0);
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);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token '-INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test242() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader("true");
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(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(treeNode0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer1.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("Q!@NE3Sp[c");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext3 = new IOContext(bufferRecycler1, "Q!@NE3Sp[c", false);
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader2 = new StringReader("Q!@NE3Sp[c");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ObjectCodec objectCodec1 = null;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
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));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader3 = new StringReader("true");
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertNotNull(stringReader3);
SerializedString serializedString0 = new SerializedString("true");
assertEquals("true", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertEquals("true", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals("true", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertEquals("true", serializedString0.getValue());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(9, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(stringReader0, stringReader3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader3));
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(boolean0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1._finishString();
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: 21]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test243() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
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: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test244() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, "qn/.BGs.|zddZ", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("+Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("qn/.BGs.|zddZ");
assertEquals("qn/.BGs.|zddZ", serializedString0.toString());
assertEquals(13, serializedString0.charLength());
assertEquals("qn/.BGs.|zddZ", serializedString0.getValue());
assertNotNull(serializedString0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token '+Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test245() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
char[] charArray0 = new char[4];
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
char char0 = '-';
char char1 = 'f';
boolean boolean0 = true;
StringReader stringReader0 = new StringReader("?NCt|ei;-./]0~wt(");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 55;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 55, (-20), true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('?' (code 63)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -18]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test246() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-186));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("?CTp,y");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer2.release();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, 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(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('?' (code 63)): 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 test247() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "'";
StringReader stringReader0 = new StringReader("'");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2472), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-2472), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
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);
byte[] byteArray0 = iOContext1.allocReadIOBuffer((-2472));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
try {
readerBasedJsonParser0.nextBooleanValue();
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); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test248() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+INF", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
SerializedString serializedString0 = new SerializedString("+INF");
assertEquals(4, serializedString0.charLength());
assertEquals("+INF", serializedString0.getValue());
assertEquals("+INF", serializedString0.toString());
assertNotNull(serializedString0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1117);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
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: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test249() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+INF", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(5);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(2);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token '+INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test250() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("No Base64Variant with name ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-1481), 68, false);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parseNegNumber();
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 test251() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("?x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("J_OU2EdYta");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = 'i';
charArray0[1] = 'Y';
charArray0[2] = '[';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 13, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(3, jsonToken0.id());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isBoolean());
assertEquals("[", jsonToken0.asString());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
int int0 = readerBasedJsonParser0.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(integer0.equals((Object)int0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test252() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(787);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("TYaTI94~ ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
stringReader1.reset();
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 219, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 126, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue((-4586L));
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(219, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals((-4586L), long0);
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test253() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals('\'', char0);
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);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
boolean boolean2 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
assertFalse(boolean2);
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);
BufferRecycler bufferRecycler1 = null;
int int0 = (-1428);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringWriter stringWriter0 = new StringWriter(1);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringWriter stringWriter1 = stringWriter0.append((CharSequence) "");
assertEquals("", stringWriter0.toString());
assertEquals("", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertNotNull(stringWriter1);
int int1 = readerBasedJsonParser0.getText((Writer) stringWriter1);
assertEquals("null", stringWriter0.toString());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("null", stringWriter1.toString());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertSame(stringWriter0, stringWriter1);
assertSame(iOContext0, iOContext1);
assertSame(stringWriter1, stringWriter0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(int1 == int0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(4, int1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = null;
try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-1428), 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 test254() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer(3032);
assertEquals(3032, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("fGsHS.s<t*u2<yb]X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1709);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = 'I';
charArray0[1] = '}';
charArray0[2] = 'Q';
charArray0[3] = 'K';
charArray0[4] = 'W';
charArray0[5] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-428), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 4201, 645, false);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-428), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'I', '}', 'Q', 'K', 'W', 'v'}, charArray0);
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);
assertEquals(6, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-428), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals("", stringWriter0.toString());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, int0);
assertArrayEquals(new char[] {'I', '}', 'Q', 'K', 'W', 'v'}, charArray0);
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);
assertEquals(6, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fGsHS': was expecting 'null', 'true', 'false' or NaN
// at [Source: (Integer); line: 1, column: 651]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test255() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocBase64Buffer(272);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2000, byteArray0.length);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
charArray0[0] = '\"';
charArray0[1] = '4';
charArray0[3] = '\"';
charArray0[4] = 'v';
charArray0[5] = '4';
charArray0[6] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 272, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, false);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\"', 'v', '4', '4', '\u0000'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertArrayEquals(new char[] {'D', 'V', 'K', '_', '\'', 'O', '|', '6'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(108);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec1, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, objectCodec2, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertNull(readerBasedJsonParser2.currentToken());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(33, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser2.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fg_87': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test256() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
String string0 = "=t#u?5Vx ;_VSj9c'";
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 97;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 97, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 3, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
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(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(2, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 97, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 817, 32, false);
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(97, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
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(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(2, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('=' (code 61)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 34]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test257() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.%BGs.|SSddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1321, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1321, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('=' (code 61)): 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 test258() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
String string0 = "true";
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 32, 33, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.getNextChar("Hk");
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 test259() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("SMbtQ)6,(no");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 98, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = '>';
charArray0[1] = 'G';
charArray0[2] = '>';
charArray0[3] = '>';
charArray0[4] = '>';
charArray0[5] = '>';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 0, 2, false);
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'>', 'G', '>', '>', '>', '>'}, charArray0);
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);
assertEquals(6, charArray0.length);
SerializedString serializedString0 = new SerializedString("g}H/rhDPr9W8E2z");
assertEquals("g}H/rhDPr9W8E2z", serializedString0.getValue());
assertEquals(15, serializedString0.charLength());
assertEquals("g}H/rhDPr9W8E2z", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'SMbtQ': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test260() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qnH.BGs.|&drZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'H': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test261() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("rH@n9#=x\"yEC4/o@+R");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
char char0 = readerBasedJsonParser0.getNextChar("rH@n9#=x\"yEC4/o@+R");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
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(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);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'H': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test262() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "0@nLQoKPlzT%xb%";
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(0);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
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(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "0@nLQoKPlzT%xb%", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
StringReader stringReader1 = new StringReader("0@nLQoKPlzT%xb%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext1 = new IOContext(bufferRecycler0, "0@nLQoKPlzT%xb%", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 9, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
StringReader stringReader2 = new StringReader("...");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-15), stringReader2, (ObjectCodec) null, charsToNameCanonicalizer3, charArray0, 1636, 831, false);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-15), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
assertEquals(0, charArray0.length);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader2);
assertNotSame(stringReader1, stringReader0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(0, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_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);
try {
readerBasedJsonParser1._handleApos();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 831
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test263() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+I");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a Number value
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test264() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
String string0 = "/";
StringReader stringReader0 = new StringReader("/");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("/");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(919);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = 'C';
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\\';
charArray0[1] = '\\';
charArray0[2] = 't';
charArray0[3] = 'o';
charArray0[4] = '\\';
charArray0[5] = 'C';
charArray0[6] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 67, stringReader1, objectCodec0, charsToNameCanonicalizer2, charArray0, 1114111, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(67, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', '\\', 't', 'o', '\\', 'C', '\\'}, charArray0);
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);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test265() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(46);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
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.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertEquals("{", jsonToken0.asString());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(JsonToken.START_OBJECT, jsonToken0);
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);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: expected close marker for Object (start marker at [Source: UNKNOWN; line: 1, column: 1])
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test266() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
StringReader stringReader1 = new StringReader("TYaTI94~ ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals(9, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: was expecting closing quote for a string value
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 14]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test267() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader(" within/between ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(32, int0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 113, 46, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(4000, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'within': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 53]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test268() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, true);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("was expecting a colon to separate field name and value");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = '4';
charArray0[1] = '4';
charArray0[2] = '4';
charArray0[3] = '4';
charArray0[4] = '\"';
charArray0[5] = '\"';
charArray0[6] = '4';
charArray0[7] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer4, charArray0, (-4780), 108, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '4', '4', '4', '\"', '\"', '4', '\"'}, charArray0);
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(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(8, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
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(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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'was': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test269() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("})m-$,5}'_R[YE9(");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("pE[n0r2QA/7iW& @@a");
assertNotNull(mockFileOutputStream0);
char[] charArray0 = new char[9];
charArray0[0] = '#';
charArray0[1] = 's';
charArray0[3] = 'B';
charArray0[4] = '2';
charArray0[4] = 'M';
charArray0[6] = 'P';
charArray0[7] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 22, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 3, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(22, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
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());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'#', 's', '\u0000', 'B', 'M', '\u0000', 'P', '#', '\u0000'}, charArray0);
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(9, charArray0.length);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte) (-36);
byteArray0[1] = (byte)92;
// Undeclared exception!
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, mockFileOutputStream0, 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 test270() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("SMbtQ)6,(no");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 98, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(2);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[20];
byteArray0[0] = (byte)100;
byteArray0[1] = (byte)43;
byteArray0[2] = (byte) (-13);
byteArray0[3] = (byte)47;
// Undeclared exception!
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, 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 test271() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("SMbtQ)6,(no");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Ng>h}DIUr");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(3);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(16);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)100;
byteArray0[1] = (byte)43;
byteArray0[2] = (byte)43;
byteArray0[3] = (byte)43;
byteArray0[4] = (byte)47;
byteArray0[5] = (byte)43;
byteArray0[6] = (byte)100;
byteArray0[7] = (byte)43;
byteArray0[8] = (byte) (-13);
// Undeclared exception!
try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, 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 test272() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("/@ai");
assertNotNull(mockFileOutputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "/@ai", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(" in field name");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 's';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2050, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 357, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2050, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'s'}, charArray0);
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(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
DataOutputStream dataOutputStream0 = new DataOutputStream(mockFileOutputStream0);
assertNotNull(dataOutputStream0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte) (-36);
byteArray0[1] = (byte)48;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(44);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0L);
assertEquals(0L, long0);
byteArray0[2] = (byte)34;
// Undeclared exception!
try {
readerBasedJsonParser1._readBinary((Base64Variant) null, dataOutputStream0, 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 test273() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "false");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = '9';
charArray0[1] = ' ';
charArray0[2] = 'A';
charArray0[3] = '{';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 65, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 65, 3, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(stringReader0, object0);
assertSame(object0, stringReader0);
assertNotNull(object0);
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
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(4, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(stringReader0, object0);
assertSame(object0, stringReader0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
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(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
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(4, charArray0.length);
readerBasedJsonParser1._skipCR();
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(stringReader0, object0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(object0, stringReader0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertArrayEquals(new char[] {'9', ' ', 'A', '{'}, charArray0);
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(4, charArray0.length);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(1);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-13);
byteArray0[1] = (byte)100;
byteArray0[2] = (byte)115;
byteArray0[3] = (byte)43;
byteArray0[4] = (byte) (-123);
byteArray0[5] = (byte) (-13);
// Undeclared exception!
try {
readerBasedJsonParser1._readBinary((Base64Variant) null, byteArrayOutputStream0, 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 test274() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 87, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 12, 111, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(87, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
String string0 = "";
// Undeclared exception!
try {
readerBasedJsonParser0._reportInvalidToken("", "");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 12
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test275() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[18];
charArray0[0] = '\\';
charArray0[1] = 'g';
charArray0[2] = '\\';
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 111, 3, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(18, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 95, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(95, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test276() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
byte[] byteArray0 = iOContext1.allocBase64Buffer(3351);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(3351, byteArray0.length);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("5K");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0.getNextChar(")<");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals('5', 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);
SerializedString serializedString0 = new SerializedString(")<");
assertEquals(")<", serializedString0.toString());
assertEquals(")<", serializedString0.getValue());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'K': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test277() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJR*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(51);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '(';
charArray0[1] = '(';
charArray0[2] = '(';
charArray0[3] = '(';
charArray0[4] = '(';
charArray0[5] = '(';
charArray0[6] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 4000, 94, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'(', '(', '(', '(', '(', '(', '('}, charArray0);
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);
assertEquals(7, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("|K+MBSh~y$BxvQ\"oJR*", jsonToken0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('|', char0);
assertArrayEquals(new char[] {'|', 'K', '+', 'M', 'B', 'S', 'h'}, charArray0);
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);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("|K+MBSh~y$BxvQ\"oJR*");
assertEquals("|K+MBSh~y$BxvQ\"oJR*", serializedString0.getValue());
assertEquals("|K+MBSh~y$BxvQ\"oJR*", serializedString0.toString());
assertEquals(19, serializedString0.charLength());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("");
assertEquals("", serializedString1.toString());
assertEquals("", serializedString1.getValue());
assertEquals(0, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
SerializedString serializedString2 = new SerializedString("");
assertEquals("", serializedString2.toString());
assertEquals("", serializedString2.getValue());
assertEquals(0, serializedString2.charLength());
assertFalse(serializedString2.equals((Object)serializedString0));
assertTrue(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'K': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 97]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test278() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.reset();
StringReader stringReader1 = new StringReader("ifQnFN");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = stringReader0.ready();
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertTrue(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1950, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1950, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(1685);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test279() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(43, int0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
SerializedString serializedString0 = new SerializedString("+Td");
assertEquals(3, serializedString0.charLength());
assertEquals("+Td", serializedString0.toString());
assertEquals("+Td", serializedString0.getValue());
assertNotNull(serializedString0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, serializedString0, true);
assertEquals(3, serializedString0.charLength());
assertEquals("+Td", serializedString0.toString());
assertEquals("+Td", serializedString0.getValue());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, serializedString0.charLength());
assertEquals("+Td", serializedString0.toString());
assertEquals("+Td", serializedString0.getValue());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("+Td");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 111, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(3, serializedString0.charLength());
assertEquals("+Td", serializedString0.toString());
assertEquals("+Td", serializedString0.getValue());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(111, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(43);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test280() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = 'X';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
charArray0[1] = 'X';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
StringReader stringReader1 = new StringReader("a}^!MGv<C3MxBb>mO");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 73, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 647, 209, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(73, readerBasedJsonParser1.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(1, readerBasedJsonParser2.getFeatureMask());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isNaN());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser2);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar("TYaTI94~ ");
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser2));
assertEquals('X', char0);
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("a}^!MGv<C3MxBb>mO");
assertEquals("a}^!MGv<C3MxBb>mO", serializedString0.toString());
assertEquals("a}^!MGv<C3MxBb>mO", serializedString0.getValue());
assertEquals(17, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'a': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 211]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test281() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(" at ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1198));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 122, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(122, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'at': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test282() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(116);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("-4.Jtg");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader1.skip(1563L);
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(6L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\"'}, charArray0);
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);
assertEquals(3, charArray0.length);
StringReader stringReader2 = new StringReader("");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-3790), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals((-3790), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test283() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("3.0fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 46, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
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());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test284() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler1, jsonEncoding0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
String string0 = "3.0fNl?J2&O&z9mG%";
StringReader stringReader0 = new StringReader("3.0fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = 'R';
charArray0[1] = 'n';
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1 == boolean0);
assertTrue(boolean1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, (-1506), false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
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(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'R', 'n', '\u0000'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: -1501]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test285() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, jsonEncoding0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("3.0fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = 'R';
charArray0[1] = 'n';
charArray0[2] = 'W';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, (-2870), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'R', 'n', 'W'}, charArray0);
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);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 47, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 108, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(47, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'R', 'n', 'W'}, charArray0);
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);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 50, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, (-2870), false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(50, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.isNaN());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {'R', 'n', 'W'}, charArray0);
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);
assertEquals(3, charArray0.length);
try {
readerBasedJsonParser2._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: -2865]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test286() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = '\\';
charArray0[1] = 'g';
charArray0[2] = '\\';
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 111, 3, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', 'g', '\\'}, charArray0);
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);
assertEquals(3, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(55);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 95, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(95, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test287() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("|H");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("8:h+G`Z%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-480), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-480), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[1];
charArray0[0] = 'C';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 85, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, (-194), false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(85, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'C'}, charArray0);
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(1, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (':' (code 58)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test288() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
char[] charArray0 = iOContext1.allocTokenBuffer();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(charArray0);
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(4000, charArray0.length);
byte[] byteArray0 = iOContext1.allocReadIOBuffer(33);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("y:*WbS1");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 56319, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 56319, false);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(56319, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
try {
readerBasedJsonParser0._reportInvalidToken("y:*WbS1", "0XB{*J/hNQo9BM<");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'y:*WbS1\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000...': was expecting 0XB{*J/hNQo9BM<
// at [Source: UNKNOWN; line: 1, column: 253]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test289() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-3309));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader2 = new StringReader("j|$PO7@dXOTjAl");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-149), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-149), 816, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-149), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
// 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 test290() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "";
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = '9';
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = 'u';
charArray0[4] = '@';
charArray0[5] = '9';
charArray0[6] = '9';
charArray0[7] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1820, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 279, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1820, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'9', '9', '9', 'u', '@', '9', '9', '9'}, charArray0);
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(8, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('u' (code 117)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test291() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 114, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 0)): 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 test292() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+I", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+I");
assertNotNull(stringReader0);
char[] charArray0 = new char[6];
charArray0[0] = '9';
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '9';
charArray0[4] = '9';
charArray0[5] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 71, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'9', '9', '9', '9', '9', '9'}, charArray0);
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);
assertEquals(6, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 6
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test293() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = 'N';
charArray0[2] = 'N';
charArray0[3] = '1';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[4] = '1';
charArray0[5] = 'N';
charArray0[6] = 'N';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 91, false);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', 'N', 'N', '1', '1', 'N', 'N'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertArrayEquals(new char[] {'\"', 'N', 'N', '1', '1', 'N', 'N'}, charArray0);
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);
assertEquals(7, charArray0.length);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar("gW", jsonToken0);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals('1', char0);
assertArrayEquals(new char[] {'\"', 'N', 'N', '1', '1', 'N', 'N'}, charArray0);
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);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('N' (code 78)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test294() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = '\\';
charArray0[1] = 'e';
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(122);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charArray0[2] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', 'e', '\\'}, charArray0);
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);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3499, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3499, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser1.getText();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3499, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser1._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3499, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('J' (code 74)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test295() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 26, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(26, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
iOContext0.releaseConcatBuffer((char[]) null);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(26, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertEquals(0L, long0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._matchToken("1VqFq1W2VqOU", 1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '1': 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 test296() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader("e Ah");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("e Ah");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = 34;
stringReader0.mark(34);
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-228), stringReader1, objectCodec1, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-228), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "UkdBd6Rj)|";
try {
readerBasedJsonParser0._matchToken("UkdBd6Rj)|", 3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Ukde': was expecting 'null', 'true', 'false' or NaN
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test297() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("b6hG/4'>m}NXl3J*c");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals('\b', char0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.getValueAsString("+I<e*vwibvzB");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals("+I<e*vwibvzB", string0);
assertNotNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, int0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertNotNull(jsonLocation0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
stringReader0.close();
System.setCurrentTimeMillis(0L);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test298() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "<5<");
assertFalse(boolean0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = bufferRecycler0.allocCharBuffer(0, 1);
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader(") ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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(4000, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._matchToken((String) null, 105);
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 test299() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocBase64Buffer(272);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(2000, byteArray0.length);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '4';
charArray0[3] = '\"';
charArray0[4] = 'v';
charArray0[5] = '4';
charArray0[6] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 272, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\"', 'v', '4', '4'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertArrayEquals(new char[] {'D', 'V', 'K', '_', '\'', 'O', '|'}, charArray0);
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);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
SerializedString serializedString0 = new SerializedString("DVK_'O|6fg_87");
assertEquals("DVK_'O|6fg_87", serializedString0.toString());
assertEquals(14, serializedString0.charLength());
assertEquals("DVK_'O|6fg_87", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("DVK_'O|6fg_87");
assertEquals("DVK_'O|6fg_87", serializedString1.getValue());
assertEquals("DVK_'O|6fg_87", serializedString1.toString());
assertEquals(14, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext3 = new IOContext(bufferRecycler1, (Object) null, true);
assertNull(iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 1, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(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);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test300() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 27, 2, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(200, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(200, charArray0.length);
}
@Test(timeout = 4000)
public void test301() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("7'/)1OcJ5tP@");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '?';
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("7'/)1OcJ5tP@");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 2541, 975, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'?'}, charArray0);
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);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("#j=");
assertEquals(3, serializedString0.charLength());
assertEquals("#j=", serializedString0.getValue());
assertEquals("#j=", serializedString0.toString());
assertNotNull(serializedString0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(2, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {'?'}, charArray0);
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);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser2.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (''' (code 39)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test302() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler1, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("u7bLb$BG<^eF[jd'.");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2455), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2455), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, BufferRecycler.CHAR_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);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_FLOAT;
char char0 = readerBasedJsonParser0.getNextChar("y5B", jsonToken0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2455), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals('u', char0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, BufferRecycler.CHAR_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);
String string0 = "";
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('b' (code 98)): 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 test303() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(boolean0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
TextBuffer textBuffer0 = iOContext2.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(textBuffer0);
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);
String string0 = readerBasedJsonParser0.nextTextValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNull(string0);
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);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, (-2356), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-2356), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test304() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("?x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("J_OU2EdYta");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = 'i';
charArray0[1] = 'Y';
charArray0[2] = '[';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 13, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("ALLOW_NUMERIC_LEADING_ZEROS");
assertEquals("ALLOW_NUMERIC_LEADING_ZEROS", serializedString0.toString());
assertEquals("ALLOW_NUMERIC_LEADING_ZEROS", serializedString0.getValue());
assertEquals(27, serializedString0.charLength());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals("ALLOW_NUMERIC_LEADING_ZEROS", serializedString0.toString());
assertEquals("ALLOW_NUMERIC_LEADING_ZEROS", serializedString0.getValue());
assertEquals(27, serializedString0.charLength());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'i', 'Y', '['}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test305() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-3380), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(2347);
assertEquals(2347, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("[]{0EKjGa%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
String string0 = readerBasedJsonParser1.nextFieldName();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser1.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(3, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
readerBasedJsonParser0._skipCR();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(stringReader0, stringReader1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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);
}
@Test(timeout = 4000)
public void test306() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 2, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertArrayEquals(new char[] {')', 'r', '4', 'X'}, charArray0);
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);
assertEquals(4, charArray0.length);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
int int0 = stringReader0.read(charArray0);
assertEquals(4, int0);
assertArrayEquals(new char[] {'F', '_', '@', 'U'}, charArray0);
assertEquals(4, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
char char0 = readerBasedJsonParser1.getNextChar("LX}&t8w5d\"uP5%", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('m', char0);
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);
SerializedString serializedString0 = new SerializedString("}H^TA?PPO&GJN");
assertEquals("}H^TA?PPO&GJN", serializedString0.getValue());
assertEquals(13, serializedString0.charLength());
assertEquals("}H^TA?PPO&GJN", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('j' (code 106)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test307() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "qn/.BGs.|zddZ", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("BppY19%w)($SNjG");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-142), stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, (-1328), 120, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-142), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4000, charArray0.length);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-142), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1425, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2);
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1425, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1._finishString();
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: 31]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test308() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "expected a valid value (number, String, array, object, 'true', 'false' or 'null')", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJ0R*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals("", stringWriter0.toString());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, 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);
readerBasedJsonParser0._skipString();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)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);
}
@Test(timeout = 4000)
public void test309() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '\"';
charArray1[1] = '\"';
charArray1[2] = '\"';
charArray1[3] = 'a';
charArray1[4] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 0, 3, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\"', 'a', '\"'}, charArray1);
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);
assertEquals(5, charArray1.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertArrayEquals(new char[] {'\"', '\"', '\"', 'a', '\"'}, charArray1);
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);
assertEquals(5, charArray1.length);
SerializedString serializedString0 = new SerializedString(")<");
assertEquals(")<", serializedString0.getValue());
assertEquals(")<", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
readerBasedJsonParser0._skipString();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertArrayEquals(new char[] {'\"', '\"', '\"', 'a', '\"'}, charArray1);
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);
assertEquals(5, charArray1.length);
System.setCurrentTimeMillis(0);
long long0 = readerBasedJsonParser0.nextLongValue(2829L);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertEquals(2829L, long0);
assertArrayEquals(new char[] {'\"', '\"', '\"', 'a', '\"'}, charArray1);
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);
assertEquals(5, charArray1.length);
}
@Test(timeout = 4000)
public void test310() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("I3>| 3\"~KT0Wp2+5\"");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 13, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer2, (char[]) null, 47, (-726), true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(13, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
String string0 = readerBasedJsonParser1.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(13, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertTrue(readerBasedJsonParser1.isClosed());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(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);
}
@Test(timeout = 4000)
public void test311() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 114, (-2815), true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
}
@Test(timeout = 4000)
public void test312() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
Integer integer0 = new Integer((-303));
assertEquals((-303), (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("string value");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
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.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext2, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, (-712), stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 613, 33, true);
assertEquals((-712), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._isNextTokenNameMaybe(1581, "DVK_'O|6fg_87");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test313() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0.getNextChar("");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('3', 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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("3^wH_]w7;eUpo&P");
assertEquals("3^wH_]w7;eUpo&P", serializedString0.toString());
assertEquals(18, serializedString0.charLength());
assertEquals("3^wH_]w7;eUpo&P", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0._finishString();
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: 37]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test314() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1114111, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._loadMore();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test315() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("du;CXu3mA%d57f:a");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = ' ';
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '+';
charArray0[4] = ';';
charArray0[5] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-596), stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 33, (-946), false);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-596), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {' ', '9', '9', '+', ';', ']'}, charArray0);
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(6, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'du': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"TYaTI94~ \"; line: 1, column: -943]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test316() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
StringReader stringReader0 = new StringReader("d.&");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[2] = 'f';
charArray0[1] = 'f';
charArray0[2] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1686, 0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'f', '1'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
assertEquals(3, charArray0.length);
ObjectCodec objectCodec0 = null;
StringReader stringReader1 = new StringReader("bed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'd': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test317() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(98);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = " -- suspect a DoS attack based on hash collisions";
StringReader stringReader0 = new StringReader(" -- suspect a DoS attack based on hash collisions");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 69, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(69, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 4, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(4, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('-' (code 45)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test318() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
String string0 = " -- suspect a DoS attack based on hash collisions";
StringReader stringReader1 = new StringReader(" -- suspect a DoS attack based on hash collisions");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 69, stringReader1, objectCodec1, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(69, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('-' (code 45)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test319() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(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);
assertEquals(4000, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
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);
assertEquals(4000, 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: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test320() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
charArray0[0] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 13, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {')'}, charArray0);
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(1, charArray0.length);
stringReader0.mark(43);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, " ");
assertFalse(boolean1 == boolean0);
assertFalse(boolean1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 97, 97, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {')'}, charArray0);
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(1, charArray0.length);
readerBasedJsonParser1._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertArrayEquals(new char[] {' '}, charArray0);
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(1, charArray0.length);
readerBasedJsonParser1.nextValue();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertTrue(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertArrayEquals(new char[] {' '}, charArray0);
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(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parsePosNumber(4181);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test321() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1114111, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1114111, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(string0);
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);
try {
readerBasedJsonParser0._handleOddValue((-886));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: 22]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test322() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("7'/)1OcJ5tP@");
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();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '?';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 46, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 248, 102, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'?'}, charArray0);
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(1, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(object0);
assertArrayEquals(new char[] {'?'}, charArray0);
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(1, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, (-176), (-176), true);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'?'}, charArray0);
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(1, charArray0.length);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (''' (code 39)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: -173]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test323() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("N@(oEyZUw");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-5034));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 109, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(109, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(109, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals('N', char0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertNotNull(serializedString0);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(109, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString1 = new SerializedString("N@(oEyZUw");
assertEquals("N@(oEyZUw", serializedString1.toString());
assertEquals("N@(oEyZUw", serializedString1.getValue());
assertEquals(9, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('@' (code 64)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test324() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("@4\bFtxaFuX$C7<0q");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1471), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1471), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('@' (code 64)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test325() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
SerializedString serializedString0 = new SerializedString("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)");
assertEquals("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)", serializedString0.getValue());
assertEquals("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)", serializedString0.toString());
assertEquals(109, serializedString0.charLength());
assertNotNull(serializedString0);
Integer integer0 = new Integer(55);
assertEquals(55, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 55, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 0, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(55, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '&', '\u0000'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'maybe': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test326() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("mL;Jc?");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader1 = new StringReader("mL;Jc?");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
iOContext0.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'mL': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test327() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 1289;
char[] charArray0 = new char[2];
charArray0[0] = '-';
charArray0[1] = 'f';
boolean boolean0 = false;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1289, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 32768, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1289, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'-', 'f'}, charArray0);
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(2, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test328() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer(3032);
assertEquals(3032, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("fGsHS.s<t*u2<yb]X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1707);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 645, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(645, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fGsHS': 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 test329() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(67);
assertEquals(67, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = 'b';
charArray0[1] = 'z';
charArray0[2] = '`';
charArray0[3] = 'g';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-2029), 1199, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'b', 'z', '`', 'g'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, 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: UNKNOWN; line: 1, column: -2028]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test330() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(3637);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
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(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('@' (code 64)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test331() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild((-2528));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer4);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
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 test332() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(116);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("0Nf/no~dK<$");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 24, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 53, 53, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', '\u0000'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("{", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', '\u0000'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser0.nextLongValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('N' (code 78)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 56]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test333() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer(0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
String string0 = "5K";
StringReader stringReader0 = new StringReader("5K");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 44, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(44, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("~*");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('K' (code 75)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test334() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("&>;L");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, 1, true);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '\u0000', '\u0000'}, charArray0);
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(4, charArray0.length);
ObjectCodec objectCodec1 = null;
StringReader stringReader1 = new StringReader("vW{ tT9=w`bx7k4");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-3207), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals((-3207), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'vW': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test335() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(116);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
char[] charArray0 = new char[2];
charArray0[0] = 'd';
charArray0[1] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 86, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1, 86, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'d', 'v'}, charArray0);
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);
assertEquals(2, charArray0.length);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNull(object0);
assertArrayEquals(new char[] {'d', 'v'}, charArray0);
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);
assertEquals(2, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler1, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 6218, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(6218, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test336() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[5];
charArray0[0] = '9';
charArray0[1] = 'U';
charArray0[2] = '5';
charArray0[3] = 'I';
charArray0[4] = 'J';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-25), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 116, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-25), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'9', 'U', '5', 'I', 'J'}, charArray0);
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);
assertEquals(5, charArray0.length);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-25), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertTrue(boolean0);
assertArrayEquals(new char[] {'#', ' ', 'I', '6', 'm'}, charArray0);
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);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-257), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-257), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-25), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(boolean1);
assertArrayEquals(new char[] {'~', '8', 'I', '6', 'm'}, charArray0);
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);
assertEquals(5, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
try {
readerBasedJsonParser1.getNextChar("# I6m~8", jsonToken0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test337() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "TYaTI94~ ";
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(939);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(84, int0);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("777[pn#H,");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
charsToNameCanonicalizer1.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 104, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(104, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('[' (code 91)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test338() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
char[] charArray0 = bufferRecycler0.allocCharBuffer(0, 1);
assertNotNull(charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(4000, charArray0.length);
StringReader stringReader0 = new StringReader("7F0L~Ab69`uX5");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 101, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('F' (code 70)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test339() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
StringReader stringReader1 = new StringReader("[ZqK!ej{6&TV]b2");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(35);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = '[';
charArray0[1] = '[';
charArray0[2] = '[';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 1545, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'[', '[', '['}, charArray0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertEquals("[", jsonToken0.asString());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertArrayEquals(new char[] {'[', '[', '['}, charArray0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
int int0 = readerBasedJsonParser0.getTextOffset();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'[', '[', '['}, charArray0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'[', '[', '['}, charArray0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test340() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader(",yC");
assertNotNull(stringReader0);
stringReader0.reset();
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.close();
System.setCurrentTimeMillis(0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test341() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 34, 0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
char char0 = readerBasedJsonParser0.getNextChar("/LVU", jsonToken0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals('y', char0);
assertArrayEquals(new char[] {'y', 'P', '2'}, charArray0);
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);
assertEquals(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("yP2i:O/iXzcGP");
assertEquals(13, serializedString0.charLength());
assertEquals("yP2i:O/iXzcGP", serializedString0.getValue());
assertEquals("yP2i:O/iXzcGP", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'P2i': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test342() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, jsonEncoding0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("P^Ud@QK[qzB!/[");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'P': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test343() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("NOT_AVAILABLE");
assertNotNull(stringReader0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotNull(textBuffer0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("5i<Z:no*l4l`,,{>'$");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 1808, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(8, charArray0.length);
SerializedString serializedString0 = new SerializedString("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)");
assertEquals("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)", serializedString0.toString());
assertEquals("maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)", serializedString0.getValue());
assertEquals(109, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('i' (code 105)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test344() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn<.BGs.|zddZ");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("5");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
stringReader1.reset();
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 86, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(86, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
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);
}
@Test(timeout = 4000)
public void test345() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
char char0 = '\"';
char[] charArray1 = iOContext0.allocTokenBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(4000, charArray1.length);
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(8000, byteArray0.length);
char char1 = '4';
charArray0[1] = '4';
int int0 = stringReader0.read(charArray0);
assertNotSame(charArray0, charArray1);
assertFalse(charArray0.equals((Object)charArray1));
assertEquals(7, int0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
assertEquals(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 117, 0, false);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charArray0, charArray1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray0.equals((Object)charArray1));
assertArrayEquals(new char[] {'~', ' ', 'a', 'T', 'I', '9', '4'}, charArray0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('~' (code 126)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test346() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2000, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
Object object1 = readerBasedJsonParser0.getInputSource();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(stringReader1, object1);
assertNotSame(stringReader1, stringReader0);
assertSame(object1, stringReader1);
assertNotSame(object1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object1.equals((Object)stringReader0));
assertNotNull(object1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, object1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(stringReader1, object1);
assertNotSame(stringReader1, stringReader0);
assertSame(object1, stringReader1);
assertNotSame(object1, stringReader0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader2 = new StringReader("-INF");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)object1));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'G';
charArray0[1] = '_';
charArray0[2] = 'h';
byte[] byteArray0 = iOContext0.allocReadIOBuffer(107);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[3] = '.';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 2, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(object1.equals((Object)stringReader0));
assertFalse(object1.equals((Object)stringReader2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'G', '_', 'h', '.'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isNumeric());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader1, object1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
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);
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: 25]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test347() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("Infinity");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1263), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-1263), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotNull(readerBasedJsonParser0);
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(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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-1263), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
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(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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1263), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(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(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);
try {
readerBasedJsonParser0._handleOddValue(35);
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); line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test348() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 55, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(55, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(55, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)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(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);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 58, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 272, 55, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(58, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\"', '\"', '4', '\"'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
try {
readerBasedJsonParser1.nextLongValue((-376L));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test349() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"Kmk'msG+jxe{", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("\"Kmk'msG+jxe{");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 35, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(boolean0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test350() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("Illegal character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 78, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals('I', char0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.getValueAsString("Illegal character '");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals("Illegal character '", string0);
assertNotNull(string0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getTextOffset();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, int0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test351() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(39, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("' (code 0x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
charsToNameCanonicalizer1.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 104, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(104, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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 test352() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 58, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 120, (-923), true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(58, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_FLOAT;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(58, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-922L), readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals((-922), readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(58, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0L, long0);
assertArrayEquals(new char[] {' '}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
// Undeclared exception!
try {
stringWriter0.append((CharSequence) "", 58, 130);
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test353() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 432, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("-INF");
assertEquals("-INF", serializedString0.getValue());
assertEquals(4, serializedString0.charLength());
assertEquals("-INF", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean1 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals("-INF", serializedString0.getValue());
assertEquals(4, serializedString0.charLength());
assertEquals("-INF", serializedString0.toString());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.getText();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.isNaN());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("-INF", string0);
assertNotNull(string0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test354() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2100));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1171, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1171, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("2qs,|+c2", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1171, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals('2', char0);
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);
SerializedString serializedString0 = new SerializedString("K#-N=MY2vd}UYMb#");
assertEquals("K#-N=MY2vd}UYMb#", serializedString0.toString());
assertEquals("K#-N=MY2vd}UYMb#", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertNotNull(serializedString0);
StringWriter stringWriter0 = new StringWriter(81);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringWriter stringWriter1 = stringWriter0.append('i');
assertEquals("i", stringWriter0.toString());
assertEquals("i", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertNotNull(stringWriter1);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1171, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals("iqs,|+c2", stringWriter0.toString());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertSame(stringWriter0, stringWriter1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(8, 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.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken1 = JsonToken.START_ARRAY;
String string0 = readerBasedJsonParser0._getText2(jsonToken1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1171, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(jsonToken1, jsonToken0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(jsonToken1.equals((Object)jsonToken0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals("[", string0);
assertNotNull(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.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test355() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("*4R)~$QknaG/");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Ji");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext0 = new IOContext(bufferRecycler0, "*4R)~$QknaG/", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
char[] charArray0 = new char[5];
charArray0[0] = '7';
charArray0[1] = '2';
charArray0[2] = '4';
charArray0[3] = ']';
charArray0[4] = 'b';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 54, false);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'7', '2', '4', ']', 'b'}, charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0._handleApos();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test356() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding((JsonEncoding) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'd';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 15, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 119, 108, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(15, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'d'}, charArray0);
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);
assertEquals(1, charArray0.length);
String string0 = readerBasedJsonParser0._parseName();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(15, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals("ockDY", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\"'}, charArray0);
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);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test357() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader1 = new StringReader("j\"s#,__.p^qJ-q");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[9];
charArray0[0] = ';';
charArray0[1] = '[';
charArray0[2] = 'c';
charArray0[3] = '\"';
charArray0[4] = '%';
charArray0[5] = '8';
charArray0[6] = 'n';
charArray0[7] = 'z';
charArray0[8] = 'O';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-218), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 33, (-218), false);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-218), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {';', '[', 'c', '\"', '%', '8', 'n', 'z', 'O'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(9, charArray0.length);
String string0 = readerBasedJsonParser0.currentName();
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-218), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertArrayEquals(new char[] {';', '[', 'c', '\"', '%', '8', 'n', 'z', 'O'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(9, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test358() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2846, 1841, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertEquals('/', char0);
assertArrayEquals(new char[] {'/', '.', 'B', 'G', 's'}, charArray0);
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(5, charArray0.length);
}
@Test(timeout = 4000)
public void test359() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('/', char0);
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);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(0, "null/arky");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 0)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test360() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '~';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1235, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test361() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader1 = new StringReader("u.+WC<O3)I:=");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext1.allocTokenBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 80, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 10, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
assertEquals(4000, charArray0.length);
boolean boolean0 = stringReader0.markSupported();
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertTrue(boolean0);
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test362() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 33, (-935), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('\n', char0);
assertArrayEquals(new char[] {'n'}, charArray0);
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);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test363() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/BG.SzddJ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 1, (-2785), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 3, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('B' (code 66)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test364() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 15]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test365() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("]@;RoJ1pKP4B;", jsonToken0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals('n', 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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("null array");
assertEquals("null array", serializedString0.getValue());
assertEquals("null array", serializedString0.toString());
assertEquals(10, serializedString0.charLength());
assertNotNull(serializedString0);
char[] charArray0 = new char[8];
charArray0[0] = '\\';
charArray0[1] = 'n';
charArray0[2] = 'n';
charArray0[3] = 'R';
charArray0[4] = '\\';
charArray0[5] = 'n';
charArray0[6] = '\\';
charArray0[7] = '\\';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1397), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 1, true);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals((-1397), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\', 'n', 'n', 'R', '\\', 'n', '\\', '\\'}, charArray0);
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);
assertEquals(8, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Trying to release buffer smaller than original
//
verifyException("com.fasterxml.jackson.core.io.IOContext", e);
}
}
@Test(timeout = 4000)
public void test366() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("SMbtQ)6,(no");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
JsonEncoding jsonEncoding2 = JsonEncoding.UTF16_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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);
IOContext iOContext4 = iOContext3.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext4.getEncoding());
assertTrue(iOContext4.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext4);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext4);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext4);
assertSame(iOContext4, iOContext3);
assertSame(iOContext4, iOContext1);
assertSame(iOContext4, iOContext0);
assertSame(iOContext4, iOContext2);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext4);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = ']';
charArray0[1] = '!';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, 1, true);
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {']', '!'}, charArray0);
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);
assertEquals(2, charArray0.length);
char char0 = readerBasedJsonParser0.getNextChar("SMbtQ)6,(no", jsonToken0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext4);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext4);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals('S', char0);
assertArrayEquals(new char[] {'S', 'M'}, charArray0);
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);
assertEquals(2, charArray0.length);
SerializedString serializedString0 = new SerializedString("SMbtQ)6,(no");
assertEquals(11, serializedString0.charLength());
assertEquals("SMbtQ)6,(no", serializedString0.getValue());
assertEquals("SMbtQ)6,(no", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'MbtQ': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test367() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "mA}=P?L9nvgMj", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("M#v7@Y*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("mA}=P?L9nvgMj");
assertEquals("mA}=P?L9nvgMj", serializedString0.toString());
assertEquals("mA}=P?L9nvgMj", serializedString0.getValue());
assertEquals(13, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'M': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test368() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2036, Integer.MAX_VALUE, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('\"', char0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._releaseBuffers();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0._reportInvalidToken("", "`$7BNB:.-14]l%");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94': was expecting `$7BNB:.-14]l%
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 10]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test369() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(object0);
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);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = 'l';
charArray0[1] = 'f';
charArray0[2] = ':';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, (Reader) null, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'l', 'f', ':'}, charArray0);
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(3, charArray0.length);
Object object1 = readerBasedJsonParser1.getInputSource();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(object1);
assertArrayEquals(new char[] {'l', 'f', ':'}, charArray0);
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(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 73, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 10, 21, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertNull(readerBasedJsonParser2.getCurrentName());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(73, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {'l', 'f', ':'}, charArray0);
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(3, charArray0.length);
String string0 = readerBasedJsonParser2.getText();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertNull(readerBasedJsonParser2.getCurrentName());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(73, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertArrayEquals(new char[] {'l', 'f', ':'}, charArray0);
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(3, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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);
ReaderBasedJsonParser readerBasedJsonParser3 = null;
try {
readerBasedJsonParser3 = new ReaderBasedJsonParser(iOContext0, 73, (Reader) null, (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 test370() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(39, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = ':';
charArray0[1] = ':';
charArray0[2] = ':';
charArray0[3] = 'J';
charArray0[4] = '~';
charArray0[5] = '~';
charArray0[6] = '~';
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2061, false);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {':', ':', ':', 'J', '~', '~', '~'}, charArray0);
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);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test371() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(652);
assertEquals(652, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader(" :A! &;W=[[vb1N");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(32, int0);
SerializedString serializedString0 = new SerializedString(" :A! &;W=[[vb1N");
assertEquals(15, serializedString0.charLength());
assertEquals(" :A! &;W=[[vb1N", serializedString0.getValue());
assertEquals(" :A! &;W=[[vb1N", serializedString0.toString());
assertNotNull(serializedString0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(integer0.equals((Object)int0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test372() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1713, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1713, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(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);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_FLOAT;
char char0 = readerBasedJsonParser0.getNextChar("ockDY\"c?", jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1713, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals('o', char0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(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);
SerializedString serializedString0 = new SerializedString("ockDY\"c?");
assertEquals(9, serializedString0.charLength());
assertEquals("ockDY\"c?", serializedString0.getValue());
assertEquals("ockDY\"c?", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("");
assertEquals("", serializedString1.getValue());
assertEquals(0, serializedString1.charLength());
assertEquals("", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ckDY': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test373() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("cr{0U2CB{p\"m");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-80), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-80), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'cr': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.io.IOContext); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test374() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader(") ");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader(") ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-3291), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-2332), 33, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-3291), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4000, charArray0.length);
Object object1 = readerBasedJsonParser0.getObjectId();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals((-3291), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4000, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 126, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(126, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.nextLongValue(33);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2332
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test375() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(2);
assertEquals(2, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1490), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals((-1490), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: (Integer); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test376() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Illegal character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("Illegal character '");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 78, 0, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._handleOddValue(44);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 79]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test377() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("vpm$A*?0");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1633, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1633, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1633, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(object0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
char[] charArray0 = new char[3];
charArray0[0] = '3';
charArray0[1] = 'E';
charArray0[2] = 'z';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2363, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, (-3547), false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(2363, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'3', 'E', 'z'}, charArray0);
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(3, charArray0.length);
try {
readerBasedJsonParser1._finishString();
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: -3536]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test378() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
Reader reader0 = null;
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 98, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser0._parsePosNumber((-1819));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test379() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(3);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, (Reader) null, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 1, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(6, charArray0.length);
JsonToken jsonToken0 = JsonToken.NOT_AVAILABLE;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(6, charArray0.length);
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant("*y", (String) null, true, '$', 97);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test380() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
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);
String string0 = "-INF";
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-1897), 0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
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);
readerBasedJsonParser0._nameStartCol = 0;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1897L), jsonLocation0.getCharOffset());
assertEquals((-1896), jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
// Undeclared exception!
try {
readerBasedJsonParser0._reportInvalidToken("Non-blocking source not (yet?) support for this format (%s)");
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 test381() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("J_OU2EdYta");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 123, 57, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 6117, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 3, 5085, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(6117, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
char char0 = readerBasedJsonParser1._decodeEscaped();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(6117, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('\u0000', char0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
}
@Test(timeout = 4000)
public void test382() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("]}");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 'E';
charArray0[1] = '/';
charArray0[2] = '/';
charArray0[3] = '#';
charArray0[4] = 'z';
charArray0[5] = '';
charArray0[6] = 'c';
charArray0[7] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 116, 0, true);
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'E', '/', '/', '#', 'z', '', 'c', 'q'}, charArray0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._matchToken("", 3);
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test383() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 33, 33, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, 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: UNKNOWN; line: 1, column: 54]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test384() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, (-211), true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
char char0 = readerBasedJsonParser0.getNextChar("TYaTI94~ ", jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals('T', char0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertNotNull(serializedString0);
StringWriter stringWriter0 = new StringWriter(2);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringWriter stringWriter1 = stringWriter0.append('T');
assertEquals("T", stringWriter0.toString());
assertEquals("T", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertNotNull(stringWriter1);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter1);
assertEquals("TYaTI94", stringWriter0.toString());
assertEquals("TYaTI94", stringWriter1.toString());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(6, int0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: -199]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test385() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = 'X';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
charArray0[1] = 'X';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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);
JsonToken jsonToken0 = JsonToken.START_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar(")<", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('X', char0);
assertArrayEquals(new char[] {'X', 'X', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString(")<");
assertEquals(")<", serializedString0.getValue());
assertEquals(")<", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'XTYaTI94': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 10]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test386() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-2089));
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 32768;
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[8];
charArray0[0] = 'f';
charArray0[1] = '-';
charArray0[2] = 'f';
charArray0[3] = 'f';
charArray0[4] = '-';
charArray0[5] = '-';
charArray0[6] = 'f';
charArray0[7] = '-';
int int1 = (-1132);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2611, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 3, (-1132), false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2611, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'f', '-', 'f', 'f', '-', '-', 'f', '-'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'X': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -1129]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test387() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
String string0 = "null/arky";
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(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);
int int0 = readerBasedJsonParser0.nextIntValue(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(2, int0);
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(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);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('a' (code 97)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test388() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[2] = 'D';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
char[] charArray1 = new char[17];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 1, (-2785), false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
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(17, charArray1.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 3, 2, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(17, charArray1.length);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test389() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1397));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_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);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding2);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("=t#u?5Vx ;_VSj9c'");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
charArray0[0] = 'j';
charArray0[1] = 'k';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 0, false);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'k'}, charArray0);
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);
assertEquals(2, charArray0.length);
char char0 = readerBasedJsonParser0.getNextChar("TYaTI94~ ", jsonToken0);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('=', char0);
assertArrayEquals(new char[] {'=', 't'}, charArray0);
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);
assertEquals(2, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 't': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test390() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "Illegal character '";
StringReader stringReader0 = new StringReader("Illegal character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 78, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
String string1 = "b";
SerializedString serializedString0 = new SerializedString("Illegal character '");
assertEquals(19, serializedString0.charLength());
assertEquals("Illegal character '", serializedString0.getValue());
assertEquals("Illegal character '", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Illegal': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test391() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_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.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_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.CHAR_TEXT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_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.CHAR_TEXT_BUFFER);
iOContext1.setEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_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.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(200);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("expected padding character '");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = 'a';
charArray0[1] = '(';
charArray0[2] = '(';
charArray0[3] = '(';
charArray0[4] = '(';
charArray0[5] = '(';
charArray0[6] = '(';
charArray0[7] = '(';
charArray0[8] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-4067), stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, (-4718), false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-4067), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'a', '(', '(', '(', '(', '(', '(', '(', '('}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_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.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(9, charArray0.length);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized character escape 'e' (code 101)
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: -4716]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test392() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = 'x';
charArray0[2] = 'x';
charArray0[3] = '\"';
charArray0[4] = 'l';
charArray0[5] = '4';
charArray0[6] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 272, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', 'x', 'x', '\"', 'l', '4', '4'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(272, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertArrayEquals(new char[] {'D', 'V', 'K', '_', '\'', 'O', '|'}, charArray0);
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(7, charArray0.length);
StringReader stringReader1 = new StringReader("DVK_'O|6fg_87");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(108);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec1, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, objectCodec2, charsToNameCanonicalizer2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(33, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isNaN());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.currentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isClosed());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
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);
try {
readerBasedJsonParser2.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test393() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = 'w';
charArray0[1] = '';
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 115, (-848), 115);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'w', ''}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
StringReader stringReader0 = new StringReader("6");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
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(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);
readerBasedJsonParser0.nextToken();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
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);
}
@Test(timeout = 4000)
public void test394() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 202, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(202, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotNull(readerBasedJsonParser0);
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);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(202, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertNotNull(jsonLocation0);
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);
assertEquals(500, JsonLocation.MAX_CONTENT_SNIPPET);
long long0 = readerBasedJsonParser0.nextLongValue(33);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(202, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33L, long0);
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);
String string0 = readerBasedJsonParser0.getText();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(202, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(string0);
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);
SerializedString serializedString0 = null;
try {
serializedString0 = new SerializedString((String) null);
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// Null String illegal for SerializedString
//
verifyException("com.fasterxml.jackson.core.io.SerializedString", e);
}
}
@Test(timeout = 4000)
public void test395() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(1, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(33);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33L, long0);
assertArrayEquals(new char[] {' '}, charArray0);
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(1, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
// Undeclared exception!
try {
stringWriter0.append((CharSequence) "", 1, (-754));
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test396() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(119);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'E';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 44, 0, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'E'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
try {
readerBasedJsonParser0._loadMoreGuaranteed();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: 45]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test397() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[3];
charArray0[0] = 'K';
charArray0[1] = 'I';
charArray0[2] = 'w';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 8000, 33, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'K', 'I', 'w'}, charArray0);
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(3, charArray0.length);
try {
readerBasedJsonParser0._loadMoreGuaranteed();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: 8034]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test398() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("Unexpected end-of-input within/between ");
assertNotNull(stringReader0);
byte[] byteArray0 = iOContext0.allocBase64Buffer(69);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2000, byteArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, "Unexpected end-of-input within/between ", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader1 = new StringReader("Unexpected end-of-input within/between ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-3040));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("W6nd^XF?L-P +Y");
assertEquals("W6nd^XF?L-P +Y", serializedString0.toString());
assertEquals(14, serializedString0.charLength());
assertEquals("W6nd^XF?L-P +Y", serializedString0.getValue());
assertNotNull(serializedString0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = '{';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 3, false);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'{'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
SerializedString serializedString1 = new SerializedString("W6nd^XF?L-P +Y");
assertEquals("W6nd^XF?L-P +Y", serializedString1.getValue());
assertEquals("W6nd^XF?L-P +Y", serializedString1.toString());
assertEquals(14, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertEquals("W6nd^XF?L-P +Y", serializedString1.getValue());
assertEquals("W6nd^XF?L-P +Y", serializedString1.toString());
assertEquals(14, serializedString1.charLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(serializedString1, serializedString0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'{'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test399() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{<R");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(46);
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 111, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(111, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("{<R");
assertEquals("{<R", serializedString0.toString());
assertEquals(3, serializedString0.charLength());
assertEquals("{<R", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(111, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals("{<R", serializedString0.toString());
assertEquals(3, serializedString0.charLength());
assertEquals("{<R", serializedString0.getValue());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
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.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);
}
@Test(timeout = 4000)
public void test400() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("3^wH_]w7;eUpo&P");
assertEquals("3^wH_]w7;eUpo&P", serializedString0.getValue());
assertEquals("3^wH_]w7;eUpo&P", serializedString0.toString());
assertEquals(18, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test401() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = stringReader0.ready();
assertTrue(boolean0);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("3^wH_]w7;eUpo&P");
assertEquals("3^wH_]w7;eUpo&P", serializedString0.getValue());
assertEquals("3^wH_]w7;eUpo&P", serializedString0.toString());
assertEquals(18, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test402() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, ")r4XF_@Um-j]h", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec2, charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
readerBasedJsonParser0._closeInput();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
}
@Test(timeout = 4000)
public void test403() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "Illegal character '";
StringReader stringReader0 = new StringReader("Illegal character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 78, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
String string1 = "b";
char char0 = readerBasedJsonParser0.getNextChar("b", jsonToken0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(78, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals('I', char0);
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);
SerializedString serializedString0 = new SerializedString("Illegal character '");
assertEquals("Illegal character '", serializedString0.getValue());
assertEquals("Illegal character '", serializedString0.toString());
assertEquals(19, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'llegal': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test404() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
String string0 = "): ";
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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.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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader1 = new StringReader(",l");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
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());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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.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);
char char0 = readerBasedJsonParser0.getNextChar(",l");
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
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());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(',', char0);
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.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);
SerializedString serializedString0 = new SerializedString("lN$.Z5^y");
assertEquals("lN$.Z5^y", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("lN$.Z5^y", serializedString0.toString());
assertNotNull(serializedString0);
StringReader stringReader2 = new StringReader("b");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
SerializedString serializedString1 = new SerializedString(",l");
assertEquals(",l", serializedString1.toString());
assertEquals(2, serializedString1.charLength());
assertEquals(",l", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
SerializedString serializedString2 = new SerializedString("lN$.Z5^y");
assertEquals("lN$.Z5^y", serializedString2.getValue());
assertEquals("lN$.Z5^y", serializedString2.toString());
assertEquals(8, serializedString2.charLength());
assertTrue(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
int int0 = serializedString2.writeUnquotedUTF8(byteArrayOutputStream0);
assertEquals("lN$.Z5^y", byteArrayOutputStream0.toString());
assertEquals(8, byteArrayOutputStream0.size());
assertEquals("lN$.Z5^y", serializedString2.getValue());
assertEquals("lN$.Z5^y", serializedString2.toString());
assertEquals(8, serializedString2.charLength());
assertNotSame(serializedString2, serializedString0);
assertNotSame(serializedString2, serializedString1);
assertTrue(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertEquals(8, int0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString2);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'l': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test405() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(39, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = '@';
charArray0[1] = '@';
charArray0[2] = '@';
charArray0[3] = 'J';
charArray0[4] = '~';
charArray0[5] = '~';
charArray0[6] = '~';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 989, false);
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'@', '@', '@', 'J', '~', '~', '~'}, charArray0);
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);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("{FkI)");
assertEquals(5, serializedString0.charLength());
assertEquals("{FkI)", serializedString0.getValue());
assertEquals("{FkI)", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'J': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test406() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 167, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(167, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(167, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
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);
char[] charArray0 = new char[9];
charArray0[0] = ',';
charArray0[1] = 'J';
charArray0[2] = '1';
charArray0[3] = '\'';
charArray0[4] = '#';
charArray0[5] = 'N';
charArray0[6] = 'Y';
charArray0[7] = '%';
charArray0[8] = 'l';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 65, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {',', 'J', '1', '\'', '#', 'N', 'Y', '%', 'l'}, charArray0);
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(9, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'J1': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test407() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("&>;L");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 3, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(4, charArray0.length);
ObjectCodec objectCodec1 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(2);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("g8_6o; 4)8ma 2x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 49, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(49, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'g8_6o': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test408() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(248);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("gW");
assertNotNull(stringReader0);
stringReader0.mark(3);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
int int0 = (-266);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'gW': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test409() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
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(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("qn/.BGs.|zddZ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[5];
charArray0[0] = 'F';
charArray0[1] = 'V';
charArray0[2] = 'F';
charArray0[4] = 'F';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, (-2478), false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'F', 'V', 'F', '\u0000', 'F'}, charArray0);
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(5, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(object0);
assertArrayEquals(new char[] {'F', 'V', 'F', '\u0000', 'F'}, charArray0);
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(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 115, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(115, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1._handleApos();
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: 27]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test410() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(114);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1104), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-1104), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextLongValue(0L);
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); line: 1, column: 21]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test411() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-582), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-678), (-954), false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-582), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
Object object1 = readerBasedJsonParser0.getInputSource();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-582), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(stringReader0, object1);
assertSame(object1, stringReader0);
assertNotNull(object1);
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);
assertEquals(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1418), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-1418), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(4000, charArray0.length);
String string0 = readerBasedJsonParser1.getText();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-1418), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertSame(stringReader0, object1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
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);
assertEquals(4000, charArray0.length);
readerBasedJsonParser1._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-1418), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertSame(stringReader0, object1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
assertEquals(4000, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
String string1 = readerBasedJsonParser0._getText2(jsonToken0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-582), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(stringReader0, object1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals("", string1);
assertNotNull(string1);
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);
assertEquals(4000, charArray0.length);
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant("TLd8n`~9N^k$`q>", "", false, '=', 3);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Base64Alphabet length must be exactly 64 (was 0)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test412() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = JsonToken.START_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar(")<", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('\"', char0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString(")<");
assertEquals(")<", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertEquals(")<", serializedString0.getValue());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals(")<", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertEquals(")<", serializedString0.getValue());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(boolean0);
assertArrayEquals(new char[] {'\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, 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: 19]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test413() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocBase64Buffer(2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[4];
charArray0[0] = '4';
charArray0[1] = '4';
charArray0[2] = '\"';
charArray0[3] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 24, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 480, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '4', '\"', '4'}, charArray0);
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);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertEquals(24, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertArrayEquals(new char[] {'4', '4', '\"', '4'}, charArray0);
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);
assertEquals(4, charArray0.length);
}
@Test(timeout = 4000)
public void test414() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-2535), 13, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._finishString2();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2535
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test415() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
stringReader0.reset();
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
charArray0[2] = '\"';
charArray0[3] = 'O';
charArray0[4] = '<';
charArray0[5] = '\\';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1897, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-850), (-954), true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\"', 'O', '<', '\\', 'q'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(object0, stringReader0);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
assertArrayEquals(new char[] {'\"', '4', '\"', 'O', '<', '\\', 'q'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '4', '\"', 'O', '<', '\\', 'q'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
String string1 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string1);
assertNotNull(string1);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant("", "ebE6FoF", true, '<', 2);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Base64Alphabet length must be exactly 64 (was 7)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test416() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
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);
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2316);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = '\\';
charArray0[1] = '\\';
charArray0[2] = '\\';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, jsonEncoding1, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '\\';
charArray1[1] = '\\';
charArray1[2] = '\\';
charArray1[4] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray1, 1, 48, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext2.equals((Object)iOContext3));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', '\\', '\\', '\u0000', '\\'}, charArray1);
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);
assertEquals(5, charArray1.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: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test417() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "null array", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(object0);
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);
Object object1 = readerBasedJsonParser0.getTypeId();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(object1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
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);
Object object2 = new Object();
assertNotNull(object2);
IOContext iOContext4 = new IOContext(bufferRecycler0, "null array", true);
assertTrue(iOContext4.isResourceManaged());
assertNull(iOContext4.getEncoding());
assertFalse(iOContext4.equals((Object)iOContext0));
assertFalse(iOContext4.equals((Object)iOContext3));
assertFalse(iOContext4.equals((Object)iOContext2));
assertFalse(iOContext4.equals((Object)iOContext1));
assertNotNull(iOContext4);
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);
IOContext iOContext5 = iOContext3.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext5.getEncoding());
assertTrue(iOContext5.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext5);
assertNotSame(iOContext0, iOContext4);
assertSame(iOContext0, iOContext3);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext5);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext4);
assertNotSame(iOContext5, iOContext2);
assertSame(iOContext5, iOContext0);
assertSame(iOContext5, iOContext3);
assertNotSame(iOContext5, iOContext1);
assertNotSame(iOContext5, iOContext4);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext4));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext4));
assertFalse(iOContext5.equals((Object)iOContext2));
assertFalse(iOContext5.equals((Object)iOContext1));
assertFalse(iOContext5.equals((Object)iOContext4));
assertNotNull(iOContext5);
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);
char[] charArray0 = new char[6];
charArray0[0] = '\\';
charArray0[1] = '\\';
charArray0[2] = '\\';
charArray0[3] = '\\';
charArray0[4] = '\\';
charArray0[5] = '\\';
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1356), 2012, true);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext4));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\', '\\', '\\', '\\', '\\', '\\'}, charArray0);
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(6, charArray0.length);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext5);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext4);
assertNotSame(iOContext1, iOContext2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext5));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext4));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(boolean1);
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);
try {
readerBasedJsonParser0._finishString();
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: 21]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test418() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 100, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(100, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
Boolean boolean2 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(100, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNull(boolean2);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(100, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNull(string0);
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);
readerBasedJsonParser0.getLastClearedToken();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(100, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
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);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: UNKNOWN; line: 1, column: 6]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test419() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "0@nLQoKPlzT%xb%";
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "0@nLQoKPlzT%xb%", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[1];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1031, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-3470), 1, false);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1031, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.getNextChar("0@nLQoKPlzT%xb%");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -3470
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test420() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1536, 122, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\\'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(1, charArray0.length);
}
@Test(timeout = 4000)
public void test421() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer(3032);
assertEquals(3032, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("fGsHS.s<t*u2<yb]X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1707);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 645, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
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(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(645, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'l';
charArray0[1] = 'o';
charArray0[2] = 'v';
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
charArray0[3] = 'o';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-730), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 2, 1, true);
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-730), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'l', 'o', 'v', 'o'}, charArray0);
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);
assertEquals(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextLongValue(645);
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 test422() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(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);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = iOContext0.withEncoding((JsonEncoding) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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(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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext3 = new IOContext(bufferRecycler1, jsonEncoding0, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 112, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(112, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, (-2598), true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(45, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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);
assertEquals(200, charArray0.length);
long long0 = readerBasedJsonParser1.nextLongValue(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(7, readerBasedJsonParser1.getCurrentTokenId());
assertEquals((-2597), readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.getCurrentToken());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals((-2597L), readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(45, readerBasedJsonParser1.getFeatureMask());
assertEquals(7, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0L, long0);
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(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);
assertEquals(200, charArray0.length);
}
@Test(timeout = 4000)
public void test423() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(string0);
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);
assertEquals(4000, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
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);
assertEquals(4000, charArray0.length);
int int0 = 38;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 38, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(38, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
String string1 = "Lr|g)i";
try {
readerBasedJsonParser1.nextLongValue(2);
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test424() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
TextBuffer textBuffer0 = iOContext2.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.size());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(textBuffer0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer((-282));
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2100));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 3, 49, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter(58);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals("", stringWriter0.toString());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0.nextLongValue(3053L);
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 test425() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
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((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn(stringReader0).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn("expected a valid value (number, String, array, object, 'true', 'false' or 'null')", (String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '';
charArray0[1] = 'Z';
charArray0[2] = 'F';
charArray0[3] = 'V';
charArray0[4] = '?';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3030, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 116, false);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object0);
assertSame(object0, stringReader0);
assertNotNull(object0);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
TypeReference<String> typeReference0 = (TypeReference<String>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Integer integer0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object0);
assertNull(integer0);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler1, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 10, false);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(5, charArray0.length);
try {
readerBasedJsonParser1.nextToken();
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test426() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('3', char0);
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);
SerializedString serializedString0 = new SerializedString("3^wH_]w7;eUpo&P");
assertEquals("3^wH_]w7;eUpo&P", serializedString0.getValue());
assertEquals("3^wH_]w7;eUpo&P", serializedString0.toString());
assertEquals(18, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test427() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
String string0 = "wl`";
char char0 = readerBasedJsonParser0.getNextChar("wl`", jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals('3', char0);
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);
SerializedString serializedString0 = new SerializedString("R754mBzrUkGi");
assertEquals("R754mBzrUkGi", serializedString0.toString());
assertEquals("R754mBzrUkGi", serializedString0.getValue());
assertEquals(12, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test428() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("3.0fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[1];
charArray0[0] = '_';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-2914), (-865), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'_'}, charArray0);
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(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._parseAposName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2914
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test429() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("[G+\r]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Integer integer0 = new Integer(33);
assertEquals(33, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler0, integer0, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNull(string0);
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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Illegal unquoted character ((CTRL-CHAR, code 13)): has to be escaped using backslash to be included in name
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test430() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.VALUE_FALSE;
char char0 = readerBasedJsonParser0.getNextChar((String) null, jsonToken0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals('', char0);
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);
SerializedString serializedString0 = new SerializedString(": was expecting closing quote for a string value");
assertEquals(": was expecting closing quote for a string value", serializedString0.toString());
assertEquals(48, serializedString0.charLength());
assertEquals(": was expecting closing quote for a string value", serializedString0.getValue());
assertNotNull(serializedString0);
StringWriter stringWriter0 = new StringWriter(3);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
byte[] byteArray0 = iOContext1.allocReadIOBuffer(2881);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNull(string0);
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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 21]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test431() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
int int0 = 1555;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int1 = 95;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-794), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 95, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-794), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test432() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[4];
charArray0[0] = '`';
int int0 = stringReader0.read(charArray0, 1, 2);
assertEquals(2, int0);
assertArrayEquals(new char[] {'`', 'y', 'P', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
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);
IOContext iOContext4 = new IOContext(bufferRecycler0, "yP2i:O/iXzcGP", true);
assertTrue(iOContext4.isResourceManaged());
assertNull(iOContext4.getEncoding());
assertFalse(iOContext4.equals((Object)iOContext0));
assertFalse(iOContext4.equals((Object)iOContext2));
assertFalse(iOContext4.equals((Object)iOContext3));
assertFalse(iOContext4.equals((Object)iOContext1));
assertNotNull(iOContext4);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 73, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 73, 47, true);
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext4));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', 'y', 'P', '\u0000'}, charArray0);
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);
assertEquals(4, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('i' (code 105)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 50]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test433() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
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);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("2qs,|+c2");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[8];
charArray0[0] = '-';
charArray0[1] = '\\';
charArray0[2] = '^';
charArray0[3] = 'B';
charArray0[4] = 'Y';
charArray0[5] = '1';
charArray0[6] = ' ';
charArray0[7] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-147), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, (-9), false);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-147), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'-', '\\', '^', 'B', 'Y', '1', ' ', '.'}, charArray0);
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(8, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 127)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: -6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test434() throws Throwable {
Object object0 = new Object();
assertNotNull(object0);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
char[] charArray0 = new char[7];
charArray0[0] = 'K';
charArray0[1] = '#';
charArray0[2] = 'm';
charArray0[3] = 'N';
charArray0[4] = 'F';
charArray0[5] = '2';
charArray0[6] = '2';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2040), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2770), 27, true);
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-2040), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'K', '#', 'm', 'N', 'F', '2', '2'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
Object object1 = readerBasedJsonParser0.getEmbeddedObject();
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-2040), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(object1);
assertArrayEquals(new char[] {'K', '#', 'm', 'N', 'F', '2', '2'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, objectCodec2, charsToNameCanonicalizer0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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.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);
try {
readerBasedJsonParser1._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (')' (code 41)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test435() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
iOContext1.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(1);
assertEquals(1L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(200);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
stringReader0.close();
int int0 = 123;
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[0];
int int1 = 396;
int int2 = 46;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1758), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-1758), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test436() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "T1T$", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("T1T$");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._handleOddName((-2975));
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test437() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("/");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
charArray0[0] = 'x';
charArray0[2] = 'x';
charArray0[3] = 'x';
charArray0[4] = '4';
charArray0[6] = 'x';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 8, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 8, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'x', '\u0000', 'x', 'x', '4', '\u0000', 'x', '\u0000'}, charArray0);
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);
assertEquals(8, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'/', '\u0000', 'x', 'x', '4', '\u0000', 'x', '\u0000'}, charArray0);
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);
assertEquals(8, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test438() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJR*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 51;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(51);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 929, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(929, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
long long0 = readerBasedJsonParser0.getValueAsLong((long) 0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(929, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0L, long0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(929, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
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);
try {
readerBasedJsonParser0.nextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('|' (code 124)): 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 test439() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer(3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
iOContext1.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
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);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(200);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = '(';
charArray0[1] = '(';
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser0._loadMoreGuaranteed();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test440() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.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(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
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: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test441() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1199);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '(';
charArray0[1] = '(';
charArray0[2] = '(';
charArray0[3] = '(';
charArray0[4] = '(';
charArray0[5] = '(';
charArray0[6] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 1779, 1314, true);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'(', '(', '(', '(', '(', '(', '('}, charArray0);
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);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// at [Source: UNKNOWN; line: 1, column: 1324]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test442() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3090);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = 'V';
charArray0[1] = '~';
charArray0[2] = 'N';
charArray0[3] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-99), (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, 13, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-99), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'V', '~', 'N', '\\'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-99), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'V', '~', 'N', '\\'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
}
@Test(timeout = 4000)
public void test443() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(object0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("Failed to de2ode VALUE_STRING as base64 (");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-585));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("Failed to de2ode VALUE_STRING as base64 (");
assertEquals("Failed to de2ode VALUE_STRING as base64 (", serializedString0.getValue());
assertEquals(41, serializedString0.charLength());
assertEquals("Failed to de2ode VALUE_STRING as base64 (", serializedString0.toString());
assertNotNull(serializedString0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-4002), stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals((-4002), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Failed': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test444() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(2000, byteArray0.length);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Failed to decode VALUE_STRING as base64 (");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
SerializedString serializedString0 = new SerializedString("Failed to decode VALUE_STRING as base64 (");
assertEquals("Failed to decode VALUE_STRING as base64 (", serializedString0.getValue());
assertEquals(41, serializedString0.charLength());
assertEquals("Failed to decode VALUE_STRING as base64 (", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Failed': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test445() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
String string0 = ") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary";
StringReader stringReader0 = new StringReader(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 1, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {')'}, charArray0);
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);
assertEquals(1, charArray0.length);
char[] charArray1 = new char[6];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '';
charArray1[2] = '';
charArray1[3] = '';
charArray1[4] = '';
charArray1[5] = '';
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 0, 3, true);
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'', '\u0000', '', '', '', ''}, charArray1);
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);
assertEquals(6, charArray1.length);
int int0 = readerBasedJsonParser1.getTextOffset();
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charArray1, charArray0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charArray1.equals((Object)charArray0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'', '\u0000', '', '', '', ''}, charArray1);
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);
assertEquals(6, charArray1.length);
try {
readerBasedJsonParser1._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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test446() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("Non-standard token 'NaN': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
char[] charArray0 = new char[1];
charArray0[0] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 118, 2, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'C'}, charArray0);
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(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(1, charArray0.length);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
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, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 58, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(58, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertNotSame(stringReader0, stringReader1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertArrayEquals(new char[] {'\''}, charArray0);
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(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(1, charArray0.length);
}
@Test(timeout = 4000)
public void test447() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
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((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(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = '';
charArray0[1] = 'Z';
charArray0[2] = 'F';
charArray0[3] = 'V';
charArray0[4] = '?';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3030, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 116, false);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
Class<Object> class0 = Object.class;
Object object0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(3030, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(object0);
assertArrayEquals(new char[] {'', 'Z', 'F', 'V', '?'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext2, iOContext1);
assertSame(iOContext1, iOContext2);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 116, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = readerBasedJsonParser1._handleApos();
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(116, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext1, iOContext2);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
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(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);
}
@Test(timeout = 4000)
public void test448() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 33, 33, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(4, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 36]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test449() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
String string0 = "3^wH_]w7;eUpo&P";
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("3^wH_]w7;eUpo&P");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('^' (code 94)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test450() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("ALLOW_MISSING_VALUES");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'o';
charArray0[1] = 't';
charArray0[2] = 't';
charArray0[3] = 'N';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 69, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 0, 568, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(69, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'o', 't', 't', 'N', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("ALLOW_MISSING_VALUES");
assertEquals("ALLOW_MISSING_VALUES", serializedString0.toString());
assertEquals("ALLOW_MISSING_VALUES", serializedString0.getValue());
assertEquals(20, serializedString0.charLength());
assertNotNull(serializedString0);
// Undeclared exception!
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test451() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertNotNull(textBuffer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2316);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("ockDY\"c?");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(90);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "ockDY\"c?", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ockDY': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test452() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
TextBuffer textBuffer0 = iOContext2.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-2100));
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 3, 49, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
ObjectCodec objectCodec1 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer1.makeChild(114);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 127)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test453() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, jsonEncoding0, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(0);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 104, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(104, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 127)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test454() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
charArray0[4] = 'i';
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2357), stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 15, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2357), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', 'i'}, charArray0);
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);
assertEquals(5, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('h' (code 104)): Expected space separating root-level values
// at [Source: (Object); line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test455() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals(9, serializedString0.charLength());
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertNotNull(serializedString0);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, (-554), stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray0, 35, (-211), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-554), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: (String)\"TYaTI94~ \"; line: 1, column: -199]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test456() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 0, 1000, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parseAposName();
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 test457() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
Reader reader0 = null;
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(object0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
String string0 = "Failed to decode VALUE_STRING as base64 (";
StringReader stringReader0 = new StringReader("Failed to decode VALUE_STRING as base64 (");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(73);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext3);
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
int int0 = 101;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, objectCodec1, charsToNameCanonicalizer3, (char[]) null, 2, 101, true);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser1._parseAposName();
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 test458() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3038), (Reader) null, objectCodec1, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3038), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3038), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNull(charArray1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3038), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNull(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(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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test459() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4019, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 126, 33, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(4019, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 33
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test460() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, objectCodec0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
byte[] byteArray1 = iOContext1.allocReadIOBuffer(117);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(byteArray1, byteArray0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(8000, byteArray1.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 73, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 33, 822, false);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
Object object1 = readerBasedJsonParser0.getTypeId();
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(object1);
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);
assertEquals(4000, charArray0.length);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec2).toString();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 2, stringReader0, objectCodec2, charsToNameCanonicalizer0);
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
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);
ObjectCodec objectCodec3 = readerBasedJsonParser1.getCodec();
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(objectCodec3, objectCodec2);
assertNotSame(objectCodec3, objectCodec0);
assertNotSame(objectCodec3, objectCodec1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(objectCodec3.equals((Object)objectCodec0));
assertFalse(objectCodec3.equals((Object)objectCodec1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(objectCodec3);
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);
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: UNKNOWN; line: 1, column: 35]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test461() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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(4000, charArray0.length);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0._finishString();
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: 9]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test462() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Ic=ZvwTm^8(:#cUM ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(56);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextIntValue(2);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Ic': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test463() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("TYaTI94~ ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[4];
charArray0[0] = '5';
charArray0[1] = '5';
charArray0[3] = '5';
charArray0[3] = '5';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 33, 4, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'5', '5', '\u0000', '5'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals('T', char0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(2, BufferRecycler.CHAR_TEXT_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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'I94': 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 test464() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = ']';
charArray0[1] = '4';
charArray0[2] = '4';
charArray0[3] = '\\';
charArray0[4] = 'I';
charArray0[5] = '\\';
SerializedString serializedString0 = new SerializedString("null array");
assertEquals("null array", serializedString0.toString());
assertEquals("null array", serializedString0.getValue());
assertEquals(10, serializedString0.charLength());
assertNotNull(serializedString0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 154, 1, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {']', '4', '4', '\\', 'I', '\\'}, charArray0);
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(6, 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: UNKNOWN; line: 1, column: 156]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test465() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, (-211), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 35, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(35, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar("TYaTI94~ ", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('T', char0);
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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(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(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals(9, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'YaTI94': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -203]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test466() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 117, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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(3, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertArrayEquals(new char[] {'y', 'P', '2'}, charArray0);
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(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("P>\",1q%X");
assertEquals("P>\",1q%X", serializedString0.toString());
assertEquals("P>\",1q%X", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'yP2i': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test467() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("yP2i:O/iXzcGP");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext3 = new IOContext(bufferRecycler1, iOContext1, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'yP2i': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test468() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2316);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = '\\';
charArray0[1] = '\\';
charArray0[2] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 33, false);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', '\\', '\\'}, charArray0);
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);
assertEquals(3, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals((-935), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('\\' (code 92)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test469() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("# I6m~8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0.getNextChar((String) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals('#', 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);
StringReader stringReader1 = new StringReader("2.2250738585072012e-308");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'I6m': 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 test470() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(200, charArray0.length);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "]*4McxEz8f";
StringReader stringReader0 = new StringReader("]*4McxEz8f");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.getNextChar("]*4McxEz8f");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input]*4McxEz8f
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test471() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(125);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("F D_Juthz]_");
assertNotNull(stringReader0);
stringReader0.reset();
char[] charArray0 = new char[8];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
charArray0[4] = '\"';
charArray0[5] = '\"';
charArray0[6] = '\"';
charArray0[7] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 97, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
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(8, charArray0.length);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
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(8, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test472() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("TYaTI94~ ");
assertEquals("TYaTI94~ ", serializedString0.toString());
assertEquals("TYaTI94~ ", serializedString0.getValue());
assertEquals(9, serializedString0.charLength());
assertNotNull(serializedString0);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(7, charArray0.length);
int int0 = readerBasedJsonParser1.getTextOffset();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0, 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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._reportInvalidToken("TYaTI94~ ");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94~ 4TYaTI94': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 2, column: 10]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test473() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("{<R");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
stringReader0.reset();
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer3.makeChild(1446);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, true);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 34, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertEquals("{", jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isScalarValue());
assertEquals(1, jsonToken0.id());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(JsonToken.START_OBJECT, 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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._finishString();
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test474() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "' (code 0x", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar((String) null, jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('\'', char0);
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);
SerializedString serializedString0 = new SerializedString("'null', 'true', 'false' or NaN");
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("r3j[$G:_");
assertEquals("r3j[$G:_", serializedString1.toString());
assertEquals("r3j[$G:_", serializedString1.getValue());
assertEquals(8, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals("r3j[$G:_", serializedString1.toString());
assertEquals("r3j[$G:_", serializedString1.getValue());
assertEquals(8, serializedString1.charLength());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(serializedString1, serializedString0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(serializedString1.equals((Object)serializedString0));
assertFalse(boolean0);
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);
StringWriter stringWriter0 = new StringWriter(2981);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals("null", stringWriter0.toString());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(4, 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);
readerBasedJsonParser0.finishToken();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)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);
}
@Test(timeout = 4000)
public void test475() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("|H");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer1.release();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(500);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1220), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
readerBasedJsonParser0.finishToken();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
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);
ObjectCodec objectCodec0 = readerBasedJsonParser0.getCodec();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(objectCodec0);
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);
char[] charArray0 = new char[5];
charArray0[0] = '-';
charArray0[1] = 'D';
charArray0[2] = 'm';
charArray0[3] = 'O';
charArray0[4] = 'q';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 104, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'-', 'D', 'm', 'O', 'q'}, charArray0);
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);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._finishString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test476() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("}rM~u8JJkzspFLFzk");
assertEquals("}rM~u8JJkzspFLFzk", serializedString0.getValue());
assertEquals(17, serializedString0.charLength());
assertEquals("}rM~u8JJkzspFLFzk", serializedString0.toString());
assertNotNull(serializedString0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1128, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1128, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
boolean boolean0 = readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals("}rM~u8JJkzspFLFzk", serializedString0.getValue());
assertEquals(17, serializedString0.charLength());
assertEquals("}rM~u8JJkzspFLFzk", serializedString0.toString());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser1.getCurrentToken());
assertEquals(11, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(11, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1128, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(boolean0);
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);
try {
readerBasedJsonParser1._finishString();
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: 21]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test477() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "No native support for writing Object Ids", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("swl\"d>Jc[[,mMKhd");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0._handleApos();
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: 33]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test478() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "1[`(%p;?W", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader(";O'l, O*/d%VB");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-273));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("G-l");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 34, stringReader0, objectCodec0, charsToNameCanonicalizer2, (char[]) null, (-1), (-980), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
double double0 = readerBasedJsonParser0.getValueAsDouble((double) (-1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals((-1.0), double0, 0.01);
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);
StringWriter stringWriter0 = new StringWriter(47);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
int int0 = readerBasedJsonParser1.releaseBuffered((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals("", stringWriter0.toString());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0, int0);
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);
try {
readerBasedJsonParser1._handleApos();
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test479() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("h");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(3);
assertEquals(1L, long0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF16_BE;
IOContext iOContext4 = iOContext3.withEncoding(jsonEncoding2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext4.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext4);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext4);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext3, iOContext4);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext4, iOContext0);
assertSame(iOContext4, iOContext3);
assertSame(iOContext4, iOContext2);
assertSame(iOContext4, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(iOContext4);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4051, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, (-2019), 1228, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(4051, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext4, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertTrue(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext4.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.getNextChar("h", jsonToken0);
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 test480() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 1, (-2785), false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
StringReader stringReader1 = new StringReader("%yB");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("Exponent indicator not followed by a digit");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader2, objectCodec1, charsToNameCanonicalizer0, charArray0, (-1404), (-3890), false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'D', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("com.fasterxml.jackson.core.JsonGenerator");
assertEquals(40, serializedString0.charLength());
assertEquals("com.fasterxml.jackson.core.JsonGenerator", serializedString0.toString());
assertEquals("com.fasterxml.jackson.core.JsonGenerator", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Exponent': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -3881]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test481() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("M#v7@Y*");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("END_OBJECT");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("M#v7@Y*");
assertEquals(7, serializedString0.charLength());
assertEquals("M#v7@Y*", serializedString0.toString());
assertEquals("M#v7@Y*", serializedString0.getValue());
assertNotNull(serializedString0);
char[] charArray0 = new char[2];
charArray0[0] = '7';
charArray0[1] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'7', 'T'}, charArray0);
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);
assertEquals(2, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'END_OBJECT': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test482() throws Throwable {
StringReader stringReader0 = new StringReader("ockDY\"c?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("No Base64Variant with name ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("ockDY\"c?");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 256, 32, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
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: UNKNOWN; line: 1, column: 257]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test483() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1904));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 34, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 33, 4051, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
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: UNKNOWN; line: 1, column: 34]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test484() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean0);
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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test485() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("f:c%;W");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(110);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1510), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-1510), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test486() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("p5r]Nt4GVBr(9V9t");
assertNotNull(stringReader0);
char[] charArray0 = new char[4];
charArray0[0] = 'N';
charArray0[1] = '1';
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
charArray0[2] = 'N';
charArray0[3] = 'N';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 3, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '1', 'N', 'N'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'p', '5', 'r', ']'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("gW");
assertEquals("gW", serializedString0.toString());
assertEquals(2, serializedString0.charLength());
assertEquals("gW", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'p5r': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test487() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
char[] charArray0 = new char[3];
charArray0[0] = 'A';
charArray0[1] = 'p';
charArray0[2] = 'S';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 470, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 51, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(470, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'A', 'p', 'S'}, charArray0);
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);
assertEquals(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test488() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
char[] charArray0 = new char[5];
IOContext iOContext0 = new IOContext(bufferRecycler0, "string value", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-126), (-2796), false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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);
assertEquals(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotNull(iOContext2);
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(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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 0, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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);
RequestPayload requestPayload0 = new RequestPayload("");
assertNotNull(requestPayload0);
readerBasedJsonParser1.setRequestPayloadOnError(requestPayload0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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(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);
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: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test489() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-571), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, (-571), true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-571), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
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(4000, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-571), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNull(string0);
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(4000, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-571), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
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(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 98, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(98, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
String string1 = readerBasedJsonParser0.nextTextValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-571), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string1);
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(4000, charArray0.length);
}
@Test(timeout = 4000)
public void test490() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, "+Infinity", true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, "+Infinity", false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("+Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(0);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[2];
charArray0[0] = 'j';
charArray0[1] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 92, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1709, 3685, false);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'v'}, charArray0);
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(2, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
// 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 test491() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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);
SerializedString serializedString0 = new SerializedString("5u$XNz6^Gey}SImX");
assertEquals("5u$XNz6^Gey}SImX", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertEquals("5u$XNz6^Gey}SImX", serializedString0.toString());
assertNotNull(serializedString0);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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);
readerBasedJsonParser0._releaseBuffers();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
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);
}
@Test(timeout = 4000)
public void test492() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-669));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charArray0[0] = '~';
charArray0[1] = '<';
charArray0[2] = 'c';
charArray0[3] = 'L';
byte[] byteArray0 = iOContext0.allocReadIOBuffer(50);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[4] = 'g';
charArray0[5] = '@';
charArray0[7] = 'f';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0.getNextChar(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertEquals(')', char0);
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);
SerializedString serializedString0 = new SerializedString("null");
assertEquals("null", serializedString0.getValue());
assertEquals("null", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'not': 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 test493() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = '\\';
byte[] byteArray0 = iOContext1.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(2000, byteArray0.length);
charArray0[1] = '\\';
charArray0[2] = 'i';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 64, 33, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\', '\\', 'i'}, charArray0);
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);
assertEquals(3, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec1).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn((String) null).when(objectCodec1).toString();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, (-360), 2687, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\', '\\', 'i'}, charArray0);
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(3, charArray0.length);
Class<String> class0 = String.class;
String string0 = readerBasedJsonParser1.readValueAs(class0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertArrayEquals(new char[] {'\\', '\\', 'i'}, charArray0);
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(3, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
String string1 = readerBasedJsonParser1.getValueAsString("");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals("", string1);
assertNotNull(string1);
assertArrayEquals(new char[] {'\\', '\\', 'i'}, charArray0);
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(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, objectCodec2, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(91, readerBasedJsonParser2.getFeatureMask());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isNaN());
assertNull(readerBasedJsonParser2.currentToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser2);
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);
// Undeclared exception!
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -360
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test494() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = 'O';
charArray0[1] = 'O';
charArray0[2] = '<';
stringReader0.reset();
String string0 = charsToNameCanonicalizer1.findSymbol(charArray0, 0, 0, 43);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'O', 'O', '<'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 33, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'O', 'O', '<'}, charArray0);
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);
assertEquals(3, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'O': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test495() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
Integer integer0 = new Integer(3032);
assertEquals(3032, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader("O2QydM");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1707);
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 645, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(645, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'O2QydM': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test496() throws Throwable {
StringReader stringReader0 = new StringReader(" in field name");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
char[] charArray0 = new char[3];
charArray0[0] = 'J';
charArray0[1] = 't';
charArray0[2] = 'F';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1474, 45, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'J', 't', 'F'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNull(charArray1);
assertArrayEquals(new char[] {'J', 't', 'F'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test497() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "null array", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext3 = new IOContext(bufferRecycler0, "null array", true);
assertNull(iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
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);
IOContext iOContext4 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext4.getEncoding());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext4);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertNotSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext4, iOContext0);
assertSame(iOContext4, iOContext2);
assertNotSame(iOContext4, iOContext1);
assertNotSame(iOContext4, iOContext3);
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext4.equals((Object)iOContext1));
assertFalse(iOContext4.equals((Object)iOContext3));
assertNotNull(iOContext4);
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);
char[] charArray0 = new char[6];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1356), 2012, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
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(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(6, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
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(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext4);
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertNotSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertNull(charArray1);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(6, charArray0.length);
}
@Test(timeout = 4000)
public void test498() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0@nLQoKPlzT%xb%");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
assertFalse(jsonToken0.isStructEnd());
assertEquals(5, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals(JsonToken.FIELD_NAME, jsonToken0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "0@nLQoKPlzT%xb%", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1642), 217, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray0);
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(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextIntValue(225);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1642
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test499() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("rVaP7!Fd");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-592));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(charArray0);
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(4000, charArray0.length);
SerializedString serializedString0 = new SerializedString("Decimal point not followed by a digit");
assertEquals("Decimal point not followed by a digit", serializedString0.toString());
assertEquals("Decimal point not followed by a digit", serializedString0.getValue());
assertEquals(37, serializedString0.charLength());
assertNotNull(serializedString0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 398, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(398, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray1 = new char[0];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 102, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray1, 33, 2, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(102, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {}, charArray1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray1.length);
SerializedString serializedString1 = new SerializedString("Ep\"!AV^");
assertEquals(7, serializedString1.charLength());
assertEquals("Ep\"!AV^", serializedString1.getValue());
assertEquals("Ep\"!AV^", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString1);
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 test500() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("[G+\r]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "[G+\r]", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 3, 44, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0.nextIntValue(3);
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 test501() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "1[`(%p;?W", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader(";O'l, O*/d%VB");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1005);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("G2");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 34, stringReader0, objectCodec0, charsToNameCanonicalizer2, (char[]) null, (-1), (-980), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter(47);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
int int0 = readerBasedJsonParser1.releaseBuffered((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals("", stringWriter0.toString());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0, int0);
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);
try {
readerBasedJsonParser1._handleApos();
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: 5]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test502() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "nul/arkQy";
StringReader stringReader0 = new StringReader("nul/arkQy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler1, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1191, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1191, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
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(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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'nul': 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 test503() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("null/arky");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "3.0fl?J2&O&z9mG%", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[4];
charArray0[0] = '4';
charArray0[1] = '.';
charArray0[2] = 'q';
charArray0[3] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2445, (-1715), true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '.', 'q', 'D'}, charArray0);
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);
assertEquals(4, charArray0.length);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(stringReader0, stringReader1);
assertNotSame(iOContext1, iOContext0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertTrue(boolean0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l'}, charArray0);
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);
assertEquals(4, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 83, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(83, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertEquals(11, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals("null", jsonToken0.asString());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals((-1714), readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-1714L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(JsonToken.VALUE_NULL, jsonToken0);
assertArrayEquals(new char[] {'/', 'a', 'r', 'k'}, charArray0);
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);
assertEquals(4, charArray0.length);
}
@Test(timeout = 4000)
public void test504() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 432, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
SerializedString serializedString0 = new SerializedString("-INF");
assertEquals("-INF", serializedString0.getValue());
assertEquals(4, serializedString0.charLength());
assertEquals("-INF", serializedString0.toString());
assertNotNull(serializedString0);
char[] charArray0 = new char[4];
charArray0[0] = '?';
charArray0[1] = 'P';
charArray0[2] = ' ';
charArray0[3] = 'I';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 86, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'?', 'P', ' ', 'I'}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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(4, charArray0.length);
int int0 = readerBasedJsonParser0.nextIntValue(3660);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(readerBasedJsonParser0.isNaN());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(432, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(3660, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
JsonToken jsonToken0 = JsonToken.VALUE_TRUE;
assertEquals(9, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isBoolean());
assertEquals("true", jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertEquals(JsonToken.VALUE_TRUE, jsonToken0);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 13]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test505() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, (-128), 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
long long0 = readerBasedJsonParser0.getValueAsLong(1160L);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(1160L, long0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
iOContext0.releaseBase64Buffer((byte[]) null);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext2));
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 1303, stringReader0, objectCodec2, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertNull(readerBasedJsonParser2.currentToken());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(1303, readerBasedJsonParser2.getFeatureMask());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = readerBasedJsonParser0.nextIntValue(1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser2));
assertEquals(1, int0);
assertArrayEquals(new char[] {' '}, charArray0);
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);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test506() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 114, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
readerBasedJsonParser0._finishString();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
readerBasedJsonParser0.clearCurrentToken();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals('s', char0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(114, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_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);
try {
readerBasedJsonParser0.nextBooleanValue();
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: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test507() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
char[] charArray1 = iOContext0.allocTokenBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
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(4000, charArray1.length);
iOContext0.releaseTokenBuffer(charArray1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
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(4000, charArray1.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("/");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1449), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 94, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1449), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
try {
readerBasedJsonParser0.nextIntValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a comment
// at [Source: (Object); line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test508() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
char[] charArray0 = new char[5];
charArray0[0] = 'o';
charArray0[1] = 'h';
charArray0[2] = '6';
charArray0[3] = '.';
charArray0[4] = '5';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 51, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 480, 2, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(51, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'o', 'h', '6', '.', '5'}, charArray0);
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(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(5, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(51, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l', '/'}, charArray0);
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(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(5, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('a' (code 97)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test509() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(49, int0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
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: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test510() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 1, (-2785), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 3, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): was expecting either '*' or '/' for a comment
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test511() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 114, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._reportInvalidToken("");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test512() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("' (code 0x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[1];
charArray0[0] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1741, 52, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'1'}, charArray0);
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);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("' (code 0x", jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals('\'', char0);
assertArrayEquals(new char[] {'\''}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._nameStartOffset = (long) 0;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('(' (code 40)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 56]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test513() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 1, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {')'}, charArray0);
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);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(')', char0);
assertArrayEquals(new char[] {')'}, charArray0);
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);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertEquals(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary", serializedString0.toString());
assertEquals(69, serializedString0.charLength());
assertEquals(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'not': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 2, column: 6]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test514() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-128);
byteArray0[1] = (byte)56;
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(byteArray1, byteArray0);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(8000, byteArray1.length);
byteArray0[2] = (byte) (-128);
byteArray0[3] = (byte)9;
byteArray0[4] = (byte)93;
byteArray0[5] = (byte) (-1);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertNotSame(byteArray0, byteArray1);
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-128), (byte)56, (byte) (-128), (byte)9, (byte)93, (byte) (-1)}, byteArray0);
assertEquals(6, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 91, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 91, (-1370), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNotNull(jsonLocation0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
try {
readerBasedJsonParser0._reportInvalidToken("");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: -1278]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test515() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader(") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-669));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = '~';
charArray0[1] = '<';
charArray0[2] = 'c';
charArray0[3] = 'L';
byte[] byteArray0 = iOContext0.allocReadIOBuffer(50);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[4] = 'g';
charArray0[5] = '.';
charArray0[6] = 'f';
charArray0[7] = 'V';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1256, (-669), false);
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', '<', 'c', 'L', 'g', '.', 'f', 'V'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertArrayEquals(new char[] {'~', '<', 'c', 'L', 'g', '.', 'f', 'V'}, charArray0);
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(500, JsonLocation.MAX_CONTENT_SNIPPET);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
try {
readerBasedJsonParser0._handleInvalidNumberStart(1, true);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 1)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 1257]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test516() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(0L, long0);
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);
}
@Test(timeout = 4000)
public void test517() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '9';
charArray0[4] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 115, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 3, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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(5, charArray0.length);
String string0 = readerBasedJsonParser0.nextTextValue();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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(5, charArray0.length);
String string1 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals("99", string1);
assertNotNull(string1);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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(5, 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: UNKNOWN; line: 1, column: 10]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test518() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, (-128), 0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader0, true);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 1303, stringReader0, objectCodec2, charsToNameCanonicalizer1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.isClosed());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertEquals(1303, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = readerBasedJsonParser2.nextToken();
assertFalse(jsonToken0.isStructEnd());
assertEquals(11, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isNumeric());
assertEquals("null", jsonToken0.asString());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(2, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.isClosed());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(11, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertEquals(1303, readerBasedJsonParser2.getFeatureMask());
assertEquals(11, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.isNaN());
assertTrue(readerBasedJsonParser2.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertEquals(JsonToken.VALUE_NULL, 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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test519() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("qn<.BGs.|zddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals(113, int0);
SerializedString serializedString0 = new SerializedString("E-<Df~|`?|Ns&X");
assertEquals(14, serializedString0.charLength());
assertEquals("E-<Df~|`?|Ns&X", serializedString0.toString());
assertEquals("E-<Df~|`?|Ns&X", serializedString0.getValue());
assertNotNull(serializedString0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test520() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Integer integer0 = new Integer(2);
assertEquals(2, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, charsToNameCanonicalizer0, false);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-806));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 3, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'9'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test521() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
charArray0[4] = 'i';
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 0, (-3779), 0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', 'i'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild('h');
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-691), stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-691), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._finishString();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: was expecting closing quote for a string value
// at [Source: (Object); line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test522() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 75, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(75, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.VALUE_FALSE;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(75, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals("false", string0);
assertNotNull(string0);
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);
String string1 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(75, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(string1);
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);
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant((String) null, "UTF8", true, 'n', 200);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Base64Alphabet length must be exactly 64 (was 4)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test523() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("|K+MBSh~y$BxvQ\"oJR*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild((-33));
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer5 = charsToNameCanonicalizer2.makeChild(1282);
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer5.bucketCount());
assertEquals(0, charsToNameCanonicalizer5.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer5.hashSeed());
assertFalse(charsToNameCanonicalizer5.maybeDirty());
assertEquals(0, charsToNameCanonicalizer5.collisionCount());
assertEquals(0, charsToNameCanonicalizer5.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer5);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer4));
assertNotNull(charsToNameCanonicalizer5);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = new char[6];
charArray0[0] = 'x';
charArray0[1] = '_';
charArray0[2] = 'w';
charArray0[3] = '%';
charArray0[4] = '#';
charArray0[5] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer4, charArray0, 1282, (-33), false);
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertTrue(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer5));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'x', '_', 'w', '%', '#', '('}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(6, charArray0.length);
try {
readerBasedJsonParser0._handleOddValue((-276));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: 1283]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test524() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'j';
charArray1[1] = '&';
charArray1[2] = '&';
charArray1[3] = 'f';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2115), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray1, 34, 3, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-2115), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', '&', '&', 'f', '\u0000'}, charArray1);
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(5, charArray1.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(0);
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-2115), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNull(object0);
assertArrayEquals(new char[] {'j', '&', '&', 'f', '\u0000'}, charArray1);
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(5, charArray1.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-2690), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-2690), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
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.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
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);
String string0 = readerBasedJsonParser0.nextFieldName();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-2115), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertArrayEquals(new char[] {'j', '&', '&', 'f', '\u0000'}, charArray1);
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(5, charArray1.length);
}
@Test(timeout = 4000)
public void test525() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'Q';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 368, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'Q'}, charArray0);
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);
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 test526() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("Q4@NE3Sp[c");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, "Q4@NE3Sp[c", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = 'P';
charArray0[1] = 'M';
charArray0[2] = 'K';
charArray0[3] = 'i';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 'K', stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(75, readerBasedJsonParser0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Q4': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test527() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
String string0 = "-INF";
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 0, 1000, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0._handleApos();
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 test528() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(5);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader(";O'l, O*/d%VB");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 5, stringReader1, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(5, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
StringWriter stringWriter0 = new StringWriter(2);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(5, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals("", stringWriter0.toString());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(0, int0);
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);
int int1 = 107;
// Undeclared exception!
try {
readerBasedJsonParser0._handleApos();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test529() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4000, charArray0.length);
iOContext0.releaseTokenBuffer(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_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(4000, charArray0.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
assertEquals(1, BufferRecycler.CHAR_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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(114);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0._handleApos();
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.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test530() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
byte[] byteArray0 = iOContext1.allocBase64Buffer(3334);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(3334, byteArray0.length);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("c9=?<]~K(St3Y'e");
assertEquals("c9=?<]~K(St3Y'e", serializedString0.toString());
assertEquals("c9=?<]~K(St3Y'e", serializedString0.getValue());
assertEquals(15, serializedString0.charLength());
assertNotNull(serializedString0);
StringReader stringReader0 = new StringReader("5K");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext2 = new IOContext(bufferRecycler1, integer0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2889), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-2889), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._handleOddName(3468);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('\u0D8C' (code 3468 / 0xd8c)): was expecting double-quote to start field name
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test531() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
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(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1178);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 85, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(85, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(85, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals('e', char0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.VALUE_TRUE;
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertEquals(9, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertEquals("true", jsonToken0.asString());
assertTrue(jsonToken0.isBoolean());
assertEquals(JsonToken.VALUE_TRUE, jsonToken0);
try {
readerBasedJsonParser0._handleOddName(85);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('U' (code 85)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test532() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn("").when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer((-1536));
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
StringReader stringReader1 = new StringReader("DVK_'O|6fg_87");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 102, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
stringReader1.close();
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
Object object0 = readerBasedJsonParser0.getInputSource();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(object0, stringReader1);
assertNotSame(object0, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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);
readerBasedJsonParser0.finishToken();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)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);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(objectCodec1, objectCodec0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(objectCodec1);
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);
try {
readerBasedJsonParser0._finishString();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test533() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
iOContext1.setEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
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);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(200);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 396, 46, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0._skipCR();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 46
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test534() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar(")<", jsonToken0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals('n', char0);
assertArrayEquals(new char[] {'n'}, charArray0);
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);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("null array");
assertEquals("null array", serializedString0.getValue());
assertEquals("null array", serializedString0.toString());
assertEquals(10, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ull': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test535() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader0 = new StringReader("u}}h36wmCD");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
readerBasedJsonParser0._loadMoreGuaranteed();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, BufferRecycler.CHAR_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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'u': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test536() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = '&';
StringReader stringReader0 = new StringReader(";O'l, O*/d%VB");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (';' (code 59)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test537() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
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(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1178);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 85, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(85, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(85, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals('e', char0);
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);
try {
readerBasedJsonParser0._parseNegNumber();
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test538() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
char[] charArray1 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
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(4000, charArray1.length);
iOContext0.releaseTokenBuffer(charArray1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
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(4000, charArray1.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("(CTRL-CHAR, code ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1449), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 94, 1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-1449), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(4000, charArray0.length);
try {
readerBasedJsonParser0.nextIntValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('(' (code 40)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (Object); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test539() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
String string0 = "TYaTI94~ ";
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
char char0 = '4';
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[4] = '<';
charArray0[5] = '\\';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 123, 3, true);
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
try {
readerBasedJsonParser0.nextIntValue(22);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test540() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3142), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-3142), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("ALLOW_MISSING_VALUES");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = true;
char[] charArray0 = new char[5];
charArray0[0] = 'o';
charArray0[1] = 't';
charArray0[2] = 't';
charArray0[3] = 'N';
charArray0[4] = 'G';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 2, 0, true);
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'o', 't', 't', 'N', 'G'}, charArray0);
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);
assertEquals(5, charArray0.length);
String string0 = readerBasedJsonParser1.getValueAsString();
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'o', 't', 't', 'N', 'G'}, charArray0);
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);
assertEquals(5, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 800, stringReader1, objectCodec2, charsToNameCanonicalizer2, charArray0, 0, 893, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(800, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {'o', 't', 't', 'N', 'G'}, charArray0);
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(5, charArray0.length);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", stringWriter0.toString());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-3142), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(0, int0);
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);
try {
readerBasedJsonParser2._parsePosNumber(79);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('o' (code 111)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test541() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._finishString();
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: 19]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test542() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("3^wH_]w7;eUpo&P");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF16_LE;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(iOContext3);
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.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
char[] charArray0 = new char[1];
charArray0[0] = '!';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, (-211), false);
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());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'!'}, charArray0);
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.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(1, charArray0.length);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
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());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertEquals('3', char0);
assertArrayEquals(new char[] {'3'}, charArray0);
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.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(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("expected a hexdigit for character escape sequence");
assertEquals(49, serializedString0.charLength());
assertEquals("expected a hexdigit for character escape sequence", serializedString0.getValue());
assertEquals("expected a hexdigit for character escape sequence", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0._finishString();
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: -191]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test543() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer((char[]) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 33, 42, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getText();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(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(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);
// 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 test544() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader(" in field name");
assertNotNull(stringReader0);
iOContext1.releaseReadIOBuffer((byte[]) null);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
iOContext1.releaseWriteEncodingBuffer((byte[]) null);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
boolean boolean0 = readerBasedJsonParser0._loadMore();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertTrue(boolean0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'in': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test545() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-INF");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[0] = 'K';
charArray0[1] = ' ';
charArray0[2] = 'P';
charArray0[3] = 't';
charArray0[4] = '\\';
charArray0[5] = '\"';
charArray0[6] = 'I';
charArray0[7] = 'D';
charArray0[8] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 3, true);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'K', ' ', 'P', 't', '\\', '\"', 'I', 'D', '9'}, charArray0);
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(9, charArray0.length);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'P': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test546() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4000, charArray0.length);
StringReader stringReader0 = new StringReader(") ");
assertNotNull(stringReader0);
iOContext0.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_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(4000, charArray0.length);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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(4000, 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: UNKNOWN; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test547() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 2, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertArrayEquals(new char[] {')', 'r', '4', 'X'}, charArray0);
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(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("'!aFd");
assertEquals(5, serializedString0.charLength());
assertEquals("'!aFd", serializedString0.toString());
assertEquals("'!aFd", serializedString0.getValue());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("@P7!of5fA %AQ=");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
RequestPayload requestPayload0 = new RequestPayload(")r4XF_@Um-j]h");
assertNotNull(requestPayload0);
readerBasedJsonParser1.setRequestPayloadOnError(requestPayload0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
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: 31]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test548() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[1] = '`';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 73, 0, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '`', '\u0000'}, charArray0);
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);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("DVK_'O|6fg_87", jsonToken0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertEquals('D', char0);
assertArrayEquals(new char[] {'D', 'V', 'K'}, charArray0);
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);
assertEquals(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertNotNull(serializedString0);
PipedInputStream pipedInputStream0 = new PipedInputStream(3088);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedOutputStream0);
DataOutputStream dataOutputStream0 = new DataOutputStream(pipedOutputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(dataOutputStream0);
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream(dataOutputStream0, 11);
assertEquals(0, pipedInputStream0.available());
assertNotNull(bufferedOutputStream0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(bufferedOutputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(filterOutputStream0);
int int0 = serializedString0.writeQuotedUTF8(filterOutputStream0);
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals(0, pipedInputStream0.available());
assertEquals(0, int0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'VK_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test549() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer1, false);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(iOContext0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = readerBasedJsonParser0.getNextChar("expected a value");
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertEquals('D', char0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("=XjxEVq Ep-0OL 0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'VK_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test550() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'd';
charArray0[1] = 'N';
charArray0[2] = 't';
charArray0[3] = 'H';
charArray0[4] = 'H';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 123, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'d', 'N', 't', 'H', 'H'}, charArray0);
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(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(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'d', 'N', 't', 'H', 'H'}, charArray0);
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(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(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("qn/.BGs.|zddZ");
assertEquals("qn/.BGs.|zddZ", serializedString0.toString());
assertEquals("qn/.BGs.|zddZ", serializedString0.getValue());
assertEquals(13, serializedString0.charLength());
assertNotNull(serializedString0);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test551() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'n';
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 0, 0, 33);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'n'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charArray1[0] = '~';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 49, (-190), false);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray1.length);
char char0 = readerBasedJsonParser0.getNextChar("{i>7q`:xJjH!");
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertEquals('e', char0);
assertArrayEquals(new char[] {'e', 'x', 'p', 'e', 'c'}, charArray1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray1.length);
SerializedString serializedString0 = new SerializedString("|j;");
assertEquals(3, serializedString0.charLength());
assertEquals("|j;", serializedString0.getValue());
assertEquals("|j;", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'xpected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -181]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test552() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
char[] charArray0 = new char[2];
charArray0[0] = '4';
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-179), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, 1, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-179), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'4', '4'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-179), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'n', 'u'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
SerializedString serializedString0 = new SerializedString("null/arky");
assertEquals(9, serializedString0.charLength());
assertEquals("null/arky", serializedString0.toString());
assertEquals("null/arky", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("null/arky");
assertEquals("null/arky", serializedString1.getValue());
assertEquals("null/arky", serializedString1.toString());
assertEquals(9, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
int int0 = serializedString1.appendQuotedUTF8(byteArray0, 8);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("null/arky", serializedString1.getValue());
assertEquals("null/arky", serializedString1.toString());
assertEquals(9, serializedString1.charLength());
assertNotSame(serializedString1, serializedString0);
assertTrue(serializedString1.equals((Object)serializedString0));
assertEquals(9, 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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(8000, byteArray0.length);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-179), readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals("null/arky", serializedString1.getValue());
assertEquals("null/arky", serializedString1.toString());
assertEquals(9, serializedString1.charLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(serializedString1, serializedString0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'/', 'a'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-179), readerBasedJsonParser0.getFeatureMask());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charArray0, charArray1);
assertNotSame(charArray1, charArray0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertArrayEquals(new char[] {'/', 'a'}, charArray0);
assertArrayEquals(new char[] {'n', 'u', 'l', 'l'}, charArray1);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, charArray0.length);
assertEquals(4, charArray1.length);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 2, column: 11]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test553() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-935), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 58, 0, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(591);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 115, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(115, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals((-935), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(11, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertArrayEquals(new char[] {' '}, charArray0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test554() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1245);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test555() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
StringReader stringReader0 = new StringReader("3.0fNl?J2&O&z9mG%");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 'X';
charArray0[1] = 'n';
charArray0[2] = 'R';
charArray0[3] = '=';
charArray0[4] = 'W';
charArray0[5] = 'f';
charArray0[6] = '+';
charArray0[7] = 'k';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-37), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 5, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-37), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'X', 'n', 'R', '=', 'W', 'f', '+', 'k'}, charArray0);
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);
assertEquals(8, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2257, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'X', 'n', 'R', '=', 'W', 'f', '+', 'k'}, charArray0);
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);
assertEquals(8, charArray0.length);
try {
readerBasedJsonParser1._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('f' (code 102)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test556() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "SZ5s~.ewygeM*~x,", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("1/RQ=|");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '~';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 11, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 122, 3, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(11, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(11, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'1'}, charArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("1/RQ=|");
assertEquals("1/RQ=|", serializedString0.getValue());
assertEquals(6, serializedString0.charLength());
assertEquals("1/RQ=|", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("SZ5s~.ewygeM*~x,");
assertEquals(17, serializedString1.charLength());
assertEquals("SZ5s~.ewygeM*~x,", serializedString1.getValue());
assertEquals("SZ5s~.ewygeM*~x,", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 11, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(11, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('/' (code 47)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test557() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-3380), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
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(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('A' (code 65)): Expected space separating root-level values
// at [Source: (StringReader); line: 1, column: 12]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test558() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("4.g");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(8);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(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());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = "J+>73B8Qc*8A";
SerializedString serializedString0 = new SerializedString("J+>73B8Qc*8A");
assertEquals("J+>73B8Qc*8A", serializedString0.getValue());
assertEquals("J+>73B8Qc*8A", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('g' (code 103)) in numeric value: Decimal point not followed by a digit
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test559() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(8000, byteArray0.length);
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1505), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar(")<", jsonToken0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1505), readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals('\"', char0);
assertArrayEquals(new char[] {'\"', '4', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString(")<");
assertEquals(")<", serializedString0.toString());
assertEquals(")<", serializedString0.getValue());
assertEquals(2, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('T' (code 84)): Expected space separating root-level values
// at [Source: (String)\"TYaTI94~ \"; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test560() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "5$$X0z6^Gey}SIfX";
SerializedString serializedString0 = new SerializedString("=");
assertEquals("=", serializedString0.toString());
assertEquals("=", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
char[] charArray0 = new char[6];
charArray0[0] = 'n';
charArray0[1] = 'n';
charArray0[2] = 'n';
charArray0[3] = 'n';
charArray0[4] = 'n';
charArray0[5] = 'n';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 100, 3, false);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'n', 'n', 'n', 'n', 'n', 'n'}, charArray0);
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(6, charArray0.length);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals("=", serializedString0.toString());
assertEquals("=", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(boolean0);
assertArrayEquals(new char[] {'n', 'n', 'n', 'n', 'n', 'n'}, charArray0);
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(6, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._finishString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test561() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("was expecting either '*' or '/' for a comment");
assertNotNull(stringReader0);
char[] charArray0 = new char[6];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
charArray0[4] = '\"';
charArray0[5] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 8000, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 690, true);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(6, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(6, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(charArray0, charArray1);
assertSame(charArray1, charArray0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(charArray1);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"'}, charArray1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(6, charArray0.length);
assertEquals(6, charArray1.length);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(charArray0, charArray1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(6, charArray0.length);
}
@Test(timeout = 4000)
public void test562() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 1, (-14), (-77));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3814, (-858), true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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(3, charArray0.length);
int int0 = readerBasedJsonParser0.getTextLength();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertEquals(0, int0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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(3, charArray0.length);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext3 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, (-3137), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-3137), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'DVK_': was expecting ('true', 'false' or 'null')
// at [Source: (Object); line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test563() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 115, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
int int0 = readerBasedJsonParser0.getTextLength();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
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(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);
}
@Test(timeout = 4000)
public void test564() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 35, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 35, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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(3, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1042, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1042, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
char char0 = readerBasedJsonParser1.getNextChar("DVK_'O|6fg_87", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1042, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('D', 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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("iu$5");
assertEquals("iu$5", serializedString0.getValue());
assertEquals("iu$5", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertNotNull(serializedString0);
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test565() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(272);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("DVK_'O|6fg_87");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext0 = new IOContext(bufferRecycler0, "DVK_'O|6fg_87", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = new char[1];
charArray0[0] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 2836, 700, false);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"'}, charArray0);
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);
assertEquals(1, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddName(3286);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test566() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("No Base64Variant with name ");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "No Base64Variant with name ", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1771, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1771, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._isNextTokenNameMaybe(101, "No Base64Variant with name ");
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test567() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = "DVK_'O|6fg_87";
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
char char0 = '`';
charArray0[0] = '`';
char char1 = 'T';
charArray0[1] = 'T';
int int0 = (-1269);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1269), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1269), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(readerBasedJsonParser0);
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);
int int1 = 256;
// Undeclared exception!
try {
readerBasedJsonParser0._isNextTokenNameMaybe(256, "DVK_'O|6fg_87");
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test568() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("null/arky");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("null/arky");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 255, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(255, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(255, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals('\n', 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(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);
SerializedString serializedString0 = new SerializedString("hhcQ)AC! 8T|");
assertEquals("hhcQ)AC! 8T|", serializedString0.toString());
assertEquals("hhcQ)AC! 8T|", serializedString0.getValue());
assertEquals(12, serializedString0.charLength());
assertNotNull(serializedString0);
StringWriter stringWriter0 = null;
try {
stringWriter0 = new StringWriter((-1479));
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Negative buffer size
//
verifyException("java.io.StringWriter", e);
}
}
@Test(timeout = 4000)
public void test569() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader0.skip(1);
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0L, long0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(stringReader0, stringReader1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(object0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
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);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in character escape sequence
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test570() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
String string0 = "ALLOW_MISSING_VALUES";
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3142), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3142), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("ALLOW_MISSING_VALUES");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 33, 0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
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(2, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3142), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
try {
readerBasedJsonParser1.getNextChar((String) null, jsonToken0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputnull
// at [Source: UNKNOWN; line: 1, column: 34]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test571() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(0);
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
try {
readerBasedJsonParser0.getNextChar("", jsonToken0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test572() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 91, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 2047, (-2847), true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(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(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);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals("", stringWriter0.toString());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parsePosNumber(123);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test573() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4809, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 256, 58, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(4809, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\\'}, charArray0);
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);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(4809, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'n'}, charArray0);
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);
assertEquals(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
char char0 = readerBasedJsonParser1.getNextChar("", jsonToken0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('u', char0);
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);
SerializedString serializedString0 = new SerializedString(" y%6buPTmt-E{[qd&R");
assertEquals(18, serializedString0.charLength());
assertEquals(" y%6buPTmt-E{[qd&R", serializedString0.toString());
assertEquals(" y%6buPTmt-E{[qd&R", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 2, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test574() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'P';
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.io.CharTypes");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._matchToken("g", 57);
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test575() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(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(2000, byteArray0.length);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = stringReader0.read();
assertEquals((-1), int0);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(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);
readerBasedJsonParser0.nextToken();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
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(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);
// Undeclared exception!
try {
readerBasedJsonParser0._matchToken("", 33);
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
@Test(timeout = 4000)
public void test576() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("|H");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer1.release();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("|H");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("|H");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 607, 1425, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNull(string0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 95, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(95, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
char char0 = readerBasedJsonParser1.getNextChar("|H");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(95, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('|', char0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._finishString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 607
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test577() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
charArray0[3] = 'P';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(object0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
IOContext iOContext1 = new IOContext(bufferRecycler1, readerBasedJsonParser0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(4, charArray0.length);
char char0 = readerBasedJsonParser0.getNextChar("_`K*VjNi");
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals('_', char0);
assertArrayEquals(new char[] {'_', '`', 'K', '*'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3432, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3432, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'_', '`', 'K', '*'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser1.getText();
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3432, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
assertArrayEquals(new char[] {'_', '`', 'K', '*'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(4, charArray0.length);
}
@Test(timeout = 4000)
public void test578() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 11, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
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(11, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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(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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0._parsePosNumber(65536);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test579() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '9';
charArray0[4] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 115, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 3, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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(5, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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(5, charArray0.length);
}
@Test(timeout = 4000)
public void test580() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader("NOT_AVAILABLE");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 's';
charArray0[1] = 'N';
charArray0[2] = '?';
charArray0[3] = 'x';
charArray0[4] = '}';
iOContext0.releaseWriteEncodingBuffer((byte[]) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
charArray0[5] = 's';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1269), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1269), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[8];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 's';
charArray1[1] = 'x';
charArray1[2] = '?';
charArray1[3] = 's';
charArray1[4] = 's';
charArray1[5] = 'x';
charArray1[6] = 's';
charArray1[7] = 'x';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 2, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'s', 'x', '?', 's', 's', 'x', 's', 'x'}, charArray1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray1.length);
int int0 = readerBasedJsonParser1.releaseBuffered((Writer) stringWriter0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals("", stringWriter0.toString());
assertNotSame(charArray1, charArray0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0, int0);
assertArrayEquals(new char[] {'s', 'x', '?', 's', 's', 'x', 's', 'x'}, charArray1);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray1.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parsePosNumber(1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test581() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
String string0 = ")r4XF_@Um-j]h";
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 2, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertArrayEquals(new char[] {')', 'r', '4', 'X'}, charArray0);
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(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
char char0 = readerBasedJsonParser1.getNextChar("LX}&t8w5d\"uP5%", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals('F', char0);
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);
SerializedString serializedString0 = new SerializedString("'!aFd");
assertEquals("'!aFd", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("'!aFd", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test582() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("_t^5_*A|ZnRx");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-2468));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
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.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '_t': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test583() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 44, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(44, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(44, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(objectCodec1, objectCodec0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(objectCodec1);
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);
try {
readerBasedJsonParser0._finishString();
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: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test584() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
StringReader stringReader0 = new StringReader("1/Q=");
assertNotNull(stringReader0);
stringReader0.reset();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 45;
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 44, 3, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(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);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test585() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("_`K*VjNi");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(object0);
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);
char[] charArray0 = new char[8];
charArray0[0] = '&';
charArray0[1] = ')';
charArray0[2] = ')';
charArray0[3] = ')';
charArray0[4] = 'i';
charArray0[5] = 'i';
charArray0[6] = 'i';
charArray0[7] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 2, false);
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'&', ')', ')', ')', 'i', 'i', 'i', 'T'}, charArray0);
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);
assertEquals(8, charArray0.length);
SerializedString serializedString0 = new SerializedString("+INF");
assertEquals(4, serializedString0.charLength());
assertEquals("+INF", serializedString0.getValue());
assertEquals("+INF", serializedString0.toString());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4, serializedString0.charLength());
assertEquals("+INF", serializedString0.getValue());
assertEquals("+INF", serializedString0.toString());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
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(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);
// Undeclared exception!
try {
readerBasedJsonParser0._finishString();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
}
}
@Test(timeout = 4000)
public void test586() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 35, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1744, 35, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(3, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 1042, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1042, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser1);
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);
char char0 = readerBasedJsonParser1.getNextChar("DVK_'O|6fg_87", jsonToken0);
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1042, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertEquals('D', char0);
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);
SerializedString serializedString0 = new SerializedString("iu$5");
assertEquals("iu$5", serializedString0.getValue());
assertEquals("iu$5", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertNotNull(serializedString0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals("iu$5", serializedString0.getValue());
assertEquals("iu$5", serializedString0.toString());
assertEquals(4, serializedString0.charLength());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(boolean0);
assertArrayEquals(new char[] {'`', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(3, charArray0.length);
try {
readerBasedJsonParser1._skipString();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.StringReader", e);
}
}
@Test(timeout = 4000)
public void test587() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
String string0 = "ALLOW_MISSING_VALUES";
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = 'B';
char[] charArray0 = new char[3];
charArray0[0] = 'O';
charArray0[1] = 'B';
charArray0[2] = 'B';
String string1 = charsToNameCanonicalizer1.findSymbol(charArray0, 0, 0, 43);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(string1.equals((Object)string0));
assertEquals("", string1);
assertNotNull(string1);
assertArrayEquals(new char[] {'O', 'B', 'B'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 33, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'O', 'B', 'B'}, charArray0);
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);
assertEquals(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test588() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
StringReader stringReader0 = new StringReader("B!*v,gut(@'a+");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "B!*v,gut(@'a+", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'B': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test589() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
long long1 = stringReader0.skip(3);
assertFalse(long1 == long0);
assertEquals(3L, long1);
char[] charArray1 = iOContext1.allocNameCopyBuffer(1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
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(200, charArray1.length);
charArray0[1] = 'T';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-72), 2274, true);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', 'T', '\u0000'}, charArray0);
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(3, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 34, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(34, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
JsonToken jsonToken0 = JsonToken.END_OBJECT;
assertTrue(jsonToken0.isStructEnd());
assertEquals(2, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertEquals("}", jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertEquals(JsonToken.END_OBJECT, jsonToken0);
readerBasedJsonParser1.finishToken();
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(34, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
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);
// Undeclared exception!
try {
readerBasedJsonParser0._matchToken("DVK_'O|6fg_87", (-72));
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -72
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test590() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotNull(iOContext2);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = '~';
charArray0[1] = 'n';
charArray0[2] = '~';
SerializedString serializedString0 = new SerializedString("5$$X0z6^Gey}SIfX");
assertEquals("5$$X0z6^Gey}SIfX", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertEquals("5$$X0z6^Gey}SIfX", serializedString0.toString());
assertNotNull(serializedString0);
StringReader stringReader1 = new StringReader("{vLuu]f+&e4^f3)^K");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, objectCodec0, charsToNameCanonicalizer2, charArray0, 0, 601, false);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', 'n', '~', '\u0000', '\u0000', '\u0000'}, charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(6, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('~' (code 126)): 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 test591() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader1 = new StringReader("JhJYvxx2s");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(256);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 256, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 91, true);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(256, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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(0, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test592() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 1618, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(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);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("8:h+G`Z%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-479), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals((-479), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(1, BufferRecycler.CHAR_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);
StringReader stringReader2 = new StringReader("");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser2 = null;
try {
readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 369, stringReader2, (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 test593() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("YI'[:=");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader1, stringReader0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(object0);
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);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-1544), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1647, 12, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-1544), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
Object object1 = readerBasedJsonParser1.getObjectId();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-1544), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNotSame(stringReader0, stringReader1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(object1);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
int int0 = 20;
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 25, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 20, (-3513), true);
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(25, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser2);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser2.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read -3513
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test594() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
int int0 = 0;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = 'O';
char[] charArray0 = new char[0];
String string0 = charsToNameCanonicalizer1.findSymbol(charArray0, 0, 0, 34);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 43, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
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 test595() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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(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);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-1897), 0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
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(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);
try {
readerBasedJsonParser0._isNextTokenNameMaybe((-823), "-INF");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: UNKNOWN; line: 1, column: -1896]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test596() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
StringReader stringReader0 = new StringReader("qn/.%BGs.|SSddZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 237, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(237, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test597() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 58, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(58, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
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);
String string0 = "";
// Undeclared exception!
try {
readerBasedJsonParser0._isNextTokenNameMaybe((-193), "");
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -193
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test598() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
String string0 = "NOT_AVAILABLE";
StringReader stringReader0 = new StringReader("NOT_AVAILABLE");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 's';
charArray0[1] = 'N';
charArray0[2] = '?';
charArray0[3] = 'x';
charArray0[4] = '}';
iOContext0.releaseWriteEncodingBuffer((byte[]) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
charArray0[5] = 's';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1269), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-1269), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(2, "NOT_AVAILABLE");
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); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test599() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(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(4000, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("?_");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
IOContext iOContext1 = new IOContext(bufferRecycler1, "?_", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1211, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 56, 299, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1211, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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(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);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_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(4000, 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: UNKNOWN; line: 1, column: 304]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test600() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 93, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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);
assertEquals(5, charArray0.length);
// 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 test601() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[0] = 'I';
charArray0[1] = '.';
charArray0[2] = 'w';
charArray0[3] = '{';
charArray0[4] = 'A';
charArray0[5] = '4';
charArray0[6] = '3';
charArray0[7] = 'g';
charArray0[8] = 'g';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 84, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 4, true);
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(84, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'I', '.', 'w', '{', 'A', '4', '3', 'g', 'g'}, charArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(9, charArray0.length);
// 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 test602() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("C~;Y");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[6];
charArray0[0] = '~';
charArray0[1] = '<';
charArray0[2] = 's';
charArray0[3] = 'b';
charArray0[4] = 'f';
charArray0[5] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 102, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', '<', 's', 'b', 'f', ')'}, charArray0);
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(6, charArray0.length);
SerializedString serializedString0 = new SerializedString("J1JG9");
assertEquals(5, serializedString0.charLength());
assertEquals("J1JG9", serializedString0.toString());
assertEquals("J1JG9", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'C': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test603() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~^", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, "TYaTI94~^", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1927));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("Current tok7n H");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[2];
charArray0[0] = 'Q';
charArray0[1] = 'C';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 103, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 50, (-122), true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(103, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'Q', 'C'}, charArray0);
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);
assertEquals(2, charArray0.length);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Current': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -114]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test604() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
String string0 = "ALLOW_MISSING_VALUES";
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char char0 = '<';
char[] charArray0 = new char[3];
charArray0[0] = 'O';
charArray0[1] = '<';
charArray0[2] = '<';
String string1 = charsToNameCanonicalizer1.findSymbol(charArray0, 0, 0, 43);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(string1.equals((Object)string0));
assertEquals("", string1);
assertNotNull(string1);
assertArrayEquals(new char[] {'O', '<', '<'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 33, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'O', '<', '<'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test605() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{<R");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
assertEquals(1, BufferRecycler.CHAR_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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(46);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, false);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(1, BufferRecycler.CHAR_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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, BufferRecycler.CHAR_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);
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar((String) null, jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
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(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);
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test606() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[1];
charArray0[0] = 'n';
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 0, 0, 33);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'n'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, charArray0.length);
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charArray1[0] = '~';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
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, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 49, (-190), false);
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'~', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray1.length);
char char0 = readerBasedJsonParser0.getNextChar("{i>7q`:xJjH!", jsonToken0);
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray1, charArray0);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertEquals('e', char0);
assertArrayEquals(new char[] {'e', 'x', 'p', 'e', 'c'}, charArray1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray1.length);
SerializedString serializedString0 = new SerializedString("|j;");
assertEquals("|j;", serializedString0.getValue());
assertEquals("|j;", serializedString0.toString());
assertEquals(3, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'xpected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -181]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test607() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("Exponent indicator not followed by a digit");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.END_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals('E', char0);
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);
SerializedString serializedString0 = new SerializedString("'null', 'true', 'false' or NaN");
assertEquals("'null', 'true', 'false' or NaN", serializedString0.getValue());
assertEquals(30, serializedString0.charLength());
assertEquals("'null', 'true', 'false' or NaN", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'xponent': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test608() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("0123456789ABCDEF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3380), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
readerBasedJsonParser0._skipCR();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-3380), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('A' (code 65)): Expected space separating root-level values
// at [Source: (StringReader); line: 2, column: 12]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test609() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = 'N';
charArray0[1] = 'N';
charArray0[2] = '9';
charArray0[3] = 'N';
charArray0[4] = '9';
charArray0[5] = '9';
charArray0[6] = '8';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 117, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
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());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', 'N', '9', 'N', '9', '9', '8'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('N' (code 78)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test610() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("null array");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(69);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-90), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 11, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-90), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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);
assertEquals(0, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test611() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(8000, byteArray0.length);
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[4] = '<';
charArray0[5] = '\\';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1897, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-850), (-954), true);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
Object object0 = readerBasedJsonParser0.getInputSource();
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertSame(object0, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
ByteArrayBuilder byteArrayBuilder0 = readerBasedJsonParser0._getByteArrayBuilder();
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.size());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(byteArrayBuilder0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("#d\"Z>");
assertEquals("#d\"Z>", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("#d\"Z>", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0._parseNegNumber();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('T' (code 84)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test612() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("2qs,|+c2");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
BufferRecycler bufferRecycler2 = new BufferRecycler();
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler2);
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);
IOContext iOContext0 = new IOContext(bufferRecycler2, charsToNameCanonicalizer0, false);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 39, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(39, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
try {
readerBasedJsonParser0._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: 19]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test613() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
charArray0[4] = 'i';
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = charsToNameCanonicalizer0.findSymbol(charArray0, 0, (-3779), 0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals("", string0);
assertNotNull(string0);
assertArrayEquals(new char[] {'N', '9', 'h', '9', 'i'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild('h');
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext1, iOContext0);
assertSame(iOContext0, iOContext1);
assertNotNull(iOContext1);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-691), stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-691), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input: was expecting closing quote for a string value
// at [Source: (Object); line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test614() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer1.release();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 1618, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
String string1 = readerBasedJsonParser0.getCurrentName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
StringReader stringReader1 = new StringReader("8:h+G`Z%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-479), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals((-479), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
try {
readerBasedJsonParser1.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (':' (code 58)): Expected space separating root-level values
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test615() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 1618, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = readerBasedJsonParser0.getValueAsString();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 79, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 1, 79, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(79, readerBasedJsonParser1.getFeatureMask());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser1.releaseBuffered((Writer) stringWriter0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.StringWriter", e);
}
}
@Test(timeout = 4000)
public void test616() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("NOT_AVAILABLE");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 's';
charArray0[1] = 'N';
charArray0[2] = '?';
charArray0[3] = 'x';
charArray0[4] = 'x';
iOContext0.releaseWriteEncodingBuffer((byte[]) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
charArray0[5] = 's';
charArray0[6] = 't';
charArray0[7] = '&';
charsToNameCanonicalizer0.release();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 1, false);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'s', 'N', '?', 'x', 'x', 's', 't', '&'}, charArray0);
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);
assertEquals(8, charArray0.length);
StringWriter stringWriter0 = new StringWriter(4086);
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals("", stringWriter0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, int0);
assertArrayEquals(new char[] {'s', 'N', '?', 'x', 'x', 's', 't', '&'}, charArray0);
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);
assertEquals(8, charArray0.length);
}
@Test(timeout = 4000)
public void test617() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
StringReader stringReader0 = new StringReader("lhjT");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2979, 39, false);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
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(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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(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(5, charArray0.length);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(34, "BIG_INTEGER");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 48]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test618() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1904));
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4051, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, 102, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(4051, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(118, "");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('v' (code 118)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test619() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 262144, 101, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertNull(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);
try {
readerBasedJsonParser0._isNextTokenNameMaybe(95, "WO gvS&I#KP");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('_' (code 95)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 262145]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test620() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader(";O'l, O*/d%VB");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'x';
charArray0[1] = 't';
charArray0[2] = '&';
charArray0[3] = 'l';
charArray0[4] = '?';
charArray0[5] = '?';
charArray0[6] = 'N';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 78, 33, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'x', 't', '&', 'l', '?', '?', 'N'}, charArray0);
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(7, charArray0.length);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (';' (code 59)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 35]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test621() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotNull(iOContext2);
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);
StringReader stringReader0 = new StringReader(";/VEtpo>HiH}/T.0\"");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-2));
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertNotNull(iOContext3);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (';' (code 59)): 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 test622() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3142), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-3142), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("ALLOW_MISSING_VALUES");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '`';
charArray0[1] = '0';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 73, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'`', '0'}, charArray0);
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);
assertEquals(2, charArray0.length);
SerializedString serializedString0 = new SerializedString("+INF");
assertEquals("+INF", serializedString0.toString());
assertEquals("+INF", serializedString0.getValue());
assertEquals(4, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'ALLOW_MISSING_VALUES': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 41]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test623() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("|H");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer1.release();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "";
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[1];
charArray0[0] = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3497, 4180, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'v'}, charArray0);
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);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("[Integer with %d digits]");
assertEquals("[Integer with %d digits]", serializedString0.toString());
assertEquals("[Integer with %d digits]", serializedString0.getValue());
assertEquals(24, serializedString0.charLength());
assertNotNull(serializedString0);
// Undeclared exception!
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 3497
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test624() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, objectCodec0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2319), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-2319), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("#]p}|,^8^1", jsonToken0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-2319), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(')', char0);
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);
SerializedString serializedString0 = new SerializedString("`W1Ckwm,jrv_Jb");
assertEquals("`W1Ckwm,jrv_Jb", serializedString0.getValue());
assertEquals("`W1Ckwm,jrv_Jb", serializedString0.toString());
assertEquals(14, serializedString0.charLength());
assertNotNull(serializedString0);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = ')';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray1, (-2), 192, true);
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {')'}, charArray1);
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);
assertEquals(1, charArray1.length);
// Undeclared exception!
try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test625() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 89, 52, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
Object object0 = readerBasedJsonParser0.getInputSource();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(object0, stringReader0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 96, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(96, readerBasedJsonParser1.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(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);
Object object1 = readerBasedJsonParser0.getCurrentValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(object1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler1, "true", false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._finishString2();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test626() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
charArray0[3] = 'P';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(object0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, readerBasedJsonParser0, true);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
// 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 test627() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 2, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
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(4, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertArrayEquals(new char[] {')', 'r', '4', 'X'}, charArray0);
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(4, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_EMBEDDED_OBJECT;
char char0 = readerBasedJsonParser0.getNextChar("'!aFd", jsonToken0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(')', char0);
assertArrayEquals(new char[] {')', 'r', '4', 'X'}, charArray0);
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(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'r4XF_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test628() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{.rZ)M");
assertNotNull(stringReader0);
char[] charArray0 = new char[8];
charArray0[0] = 'c';
charArray0[1] = '%';
charArray0[2] = 'k';
charArray0[3] = 'o';
int int0 = stringReader0.read(charArray0);
assertEquals(6, int0);
assertArrayEquals(new char[] {'{', '.', 'r', 'Z', ')', 'M', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
charArray0[4] = 'h';
charArray0[5] = '3';
charArray0[6] = ')';
charArray0[7] = '+';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1496), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 114, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals((-1496), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'{', '.', 'r', 'Z', 'h', '3', ')', '+'}, charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(8, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("^glncZ?!Mc");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'rZh3': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test629() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
iOContext1.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2012);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
char[] charArray0 = new char[3];
charArray0[0] = 'u';
charArray0[1] = '.';
charArray0[2] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 256, 3, true);
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());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'u', '.', 'D'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_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(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, 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: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test630() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 262144, 101, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertNull(string0);
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);
StringWriter stringWriter0 = new StringWriter();
assertEquals("", stringWriter0.toString());
assertNotNull(stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals("", stringWriter0.toString());
assertSame(iOContext0, iOContext1);
assertEquals(0, int0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parsePosNumber((-3137));
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test631() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, charsToNameCanonicalizer0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
StringReader stringReader0 = new StringReader("...");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[2] = 'f';
charArray0[1] = 'f';
charArray0[2] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1686, 0, true);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'f', '1'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
assertEquals(3, charArray0.length);
ObjectCodec objectCodec0 = null;
StringReader stringReader1 = new StringReader("bed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): 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 test632() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 1, (-2785), false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000'}, charArray1);
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(1, charArray1.length);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser0.getNextChar("LX}&t8w5d\"uP5%", jsonToken0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charArray1, charArray0);
assertFalse(charArray1.equals((Object)charArray0));
assertEquals('/', char0);
assertArrayEquals(new char[] {'/'}, charArray1);
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(1, charArray1.length);
SerializedString serializedString0 = new SerializedString("qn/.BGs.|zddZ");
assertEquals(13, serializedString0.charLength());
assertEquals("qn/.BGs.|zddZ", serializedString0.toString());
assertEquals("qn/.BGs.|zddZ", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('.' (code 46)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -2782]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test633() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 8, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {}, charArray0);
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.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);
assertEquals(0, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test634() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(8000, byteArray0.length);
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[4] = '<';
charArray0[5] = '\\';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1897, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-850), (-954), true);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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(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);
assertEquals(7, charArray0.length);
Object object0 = readerBasedJsonParser0.getInputSource();
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(object0, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(object0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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(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);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertArrayEquals(new char[] {'\"', '4', '|', '\u0000', '<', '\\', 'q'}, charArray0);
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(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);
assertEquals(7, charArray0.length);
readerBasedJsonParser0._skipCR();
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1897, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertArrayEquals(new char[] {'T', 'Y', 'a', 'T', 'I', '9', '4'}, charArray0);
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(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);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("#d\"Z>");
assertEquals(5, serializedString0.charLength());
assertEquals("#d\"Z>", serializedString0.toString());
assertEquals("#d\"Z>", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test635() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertTrue(textBuffer0.hasTextAsCharacters());
assertNotNull(textBuffer0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(994);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
StringReader stringReader1 = new StringReader("TYaTI94~ ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test636() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("{<R");
assertNotNull(stringReader0);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(byteArray0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(46);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer3, false);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertEquals("{", jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertEquals(1, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonToken.START_OBJECT, jsonToken0);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
}
@Test(timeout = 4000)
public void test637() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[7];
charArray0[5] = '\"';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(8000, byteArray0.length);
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[3] = 'O';
charArray0[4] = '<';
charArray0[5] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 12, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, (-43), true);
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(12, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '4', '|', 'O', '<', '\\', '\u0000'}, charArray0);
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(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(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonToken jsonToken0 = JsonToken.END_OBJECT;
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals(2, jsonToken0.id());
assertTrue(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertEquals("}", jsonToken0.asString());
assertEquals(JsonToken.END_OBJECT, jsonToken0);
readerBasedJsonParser0.finishToken();
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(12, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertArrayEquals(new char[] {'\u0000', '4', '|', 'O', '<', '\\', '\u0000'}, charArray0);
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(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(7, charArray0.length);
}
@Test(timeout = 4000)
public void test638() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("): ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.releaseTokenBuffer(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotSame(byteArray1, byteArray0);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(8000, byteArray1.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, objectCodec0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 2051, (-976), true);
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4000, charArray0.length);
try {
readerBasedJsonParser0.nextTextValue();
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: UNKNOWN; line: 1, column: -974]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test639() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
byte[] byteArray1 = iOContext1.allocWriteEncodingBuffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(byteArray1, byteArray0);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArray1);
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(8000, byteArray1.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext2 = new IOContext(bufferRecycler1, jsonEncoding0, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(jsonEncoding0, jsonEncoding1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertSame(jsonEncoding1, jsonEncoding0);
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext3);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2566), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3, (char[]) null, 78, 33, false);
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-2566), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
// Undeclared exception!
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test640() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
char[] charArray0 = new char[3];
charArray0[0] = '`';
charArray0[1] = 'T';
charArray0[2] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 0, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'`', 'T', ')'}, charArray0);
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(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("+INF");
assertEquals(4, serializedString0.charLength());
assertEquals("+INF", serializedString0.getValue());
assertEquals("+INF", serializedString0.toString());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'DVK_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test641() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer0.makeChild((-856));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'DVK_': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test642() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
Object object0 = new Object();
assertNotNull(object0);
boolean boolean0 = true;
boolean boolean1 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[5];
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '9';
charArray0[4] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 115, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 3, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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);
assertEquals(5, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(115, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(7, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
assertArrayEquals(new char[] {'\u0000', '9', '9', '9', '9'}, charArray0);
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);
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: UNKNOWN; line: 1, column: 10]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test643() throws Throwable {
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
Integer integer0 = new Integer(3032);
assertEquals(3032, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("fGsHS.s<t*u2<yb]X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
SerializedString serializedString0 = new SerializedString("fGsHS.s<t*u2<yb]X");
assertEquals("fGsHS.s<t*u2<yb]X", serializedString0.getValue());
assertEquals("fGsHS.s<t*u2<yb]X", serializedString0.toString());
assertEquals(17, serializedString0.charLength());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("fGsHS.s<t*u2<yb]X");
assertEquals(17, serializedString1.charLength());
assertEquals("fGsHS.s<t*u2<yb]X", serializedString1.getValue());
assertEquals("fGsHS.s<t*u2<yb]X", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
char[] charArray0 = new char[3];
charArray0[0] = 'O';
charArray0[1] = '$';
charArray0[2] = 'n';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 119, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 45, (-850), false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(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.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(119, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'O', '$', 'n'}, charArray0);
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);
assertEquals(3, 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: UNKNOWN; line: 1, column: -830]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test644() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(1, BufferRecycler.CHAR_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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
assertEquals(1, BufferRecycler.CHAR_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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 9, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '&', '\u0000'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_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(4, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 4
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test645() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 1754, 33, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 44, (-976), false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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);
// Undeclared exception!
try {
readerBasedJsonParser1._skipString();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test646() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "' (code 0x");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("' (code 0x");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals(39, int0);
char[] charArray0 = new char[7];
charArray0[0] = '@';
charArray0[1] = '@';
charArray0[2] = '@';
charArray0[3] = 'J';
charArray0[4] = '~';
charArray0[5] = '~';
charArray0[6] = '~';
SerializedString serializedString0 = new SerializedString("{FkI)");
assertEquals("{FkI)", serializedString0.getValue());
assertEquals(5, serializedString0.charLength());
assertEquals("{FkI)", serializedString0.toString());
assertNotNull(serializedString0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2787), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 39, 2876, false);
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals((-2787), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'@', '@', '@', 'J', '~', '~', '~'}, charArray0);
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);
assertEquals(7, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._skipString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 39
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test647() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
String string0 = "SP0nR,Fk1nZr<{Q6h";
StringReader stringReader0 = new StringReader("SP0nR,Fk1nZr<{Q6h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1401);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
charsToNameCanonicalizer0.release();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1401, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1401, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
try {
readerBasedJsonParser0._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: 35]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test648() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(91);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("X1VMi");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
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);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[3];
charArray0[0] = '0';
charArray0[1] = 'g';
charArray0[2] = '^';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 256, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 91, 2, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(256, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'0', 'g', '^'}, charArray0);
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);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0.nextToken();
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 test649() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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(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);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 262144, 101, true);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
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(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);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertNull(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(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);
try {
readerBasedJsonParser0._handleInvalidNumberStart(507, true);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('\u01FB' (code 507 / 0x1fb)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// at [Source: UNKNOWN; line: 1, column: 262145]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test650() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader("+y]wOO{G)aV}!A");
assertNotNull(stringReader0);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotNull(byteArray0);
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(2000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 955, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
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(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(955, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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);
try {
readerBasedJsonParser0.nextToken();
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: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test651() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(248);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader0 = new StringReader("+");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertTrue(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("\"c+");
assertEquals("\"c+", serializedString0.toString());
assertEquals(3, serializedString0.charLength());
assertEquals("\"c+", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in a Number value
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test652() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = 'C';
charArray0[1] = '+';
charArray0[2] = 'e';
charArray0[3] = '>';
long long0 = stringReader0.skip(33);
assertEquals(13L, long0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1271, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 50, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1271, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'C', '+', 'e', '>'}, charArray0);
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);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("+INF");
assertEquals(4, serializedString0.charLength());
assertEquals("+INF", serializedString0.toString());
assertEquals("+INF", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test653() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("-4.Jtg");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("v&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(102);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
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);
char[] charArray0 = new char[4];
charArray0[0] = '\\';
charArray0[1] = 'h';
charArray0[2] = '\\';
charArray0[3] = '\\';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 117, 102, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(stringReader0.equals((Object)stringReader1));
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);
assertArrayEquals(new char[] {'\\', 'h', '\\', '\\'}, charArray0);
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);
assertEquals(4, charArray0.length);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
char char0 = readerBasedJsonParser1.getNextChar("", jsonToken0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(stringReader0.equals((Object)stringReader1));
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));
assertEquals('-', char0);
assertArrayEquals(new char[] {'-', '4', '.', 'J'}, charArray0);
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);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("was expecting double-quote to start field name");
assertEquals(46, serializedString0.charLength());
assertEquals("was expecting double-quote to start field name", serializedString0.toString());
assertEquals("was expecting double-quote to start field name", serializedString0.getValue());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'tg': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test654() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[0] = 'D';
charArray0[1] = 'd';
charArray0[2] = 't';
charArray0[3] = 'N';
charArray0[4] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'D', 'd', 't', 'N', '1'}, charArray0);
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(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertArrayEquals(new char[] {'q', 'n', '/', '.', 'B'}, charArray0);
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(5, charArray0.length);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
char char0 = readerBasedJsonParser0.getNextChar("gW", jsonToken0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals('q', char0);
assertArrayEquals(new char[] {'q', 'n', '/', '.', 'B'}, charArray0);
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(5, charArray0.length);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test655() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[5];
charArray0[1] = 'd';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-214));
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, (-214), true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'\u0000', 'd', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: -197]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test656() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader("2qs,|+c2");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[9];
charArray0[0] = '7';
charArray0[1] = '<';
charArray0[2] = '?';
charArray0[3] = '*';
charArray0[4] = 'S';
charArray0[5] = 'm';
charArray0[6] = '?';
charArray0[7] = 'l';
charArray0[8] = '}';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 48, true);
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'7', '<', '?', '*', 'S', 'm', '?', 'l', '}'}, charArray0);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(9, charArray0.length);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 19]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test657() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
iOContext0.setEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
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);
StringReader stringReader0 = new StringReader("bM 3");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-977));
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
StringReader stringReader1 = new StringReader("expected padding character '");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotNull(iOContext1);
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);
char[] charArray0 = new char[9];
charArray0[0] = 'a';
charArray0[1] = 'a';
charArray0[2] = 'a';
charArray0[3] = 'a';
charArray0[4] = 'a';
charArray0[5] = '(';
charArray0[6] = '%';
charArray0[7] = '(';
charArray0[8] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-2058), 2, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'a', 'a', 'a', 'a', 'a', '(', '%', '(', '$'}, charArray0);
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);
assertEquals(9, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2058
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test658() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 93, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'N', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 91, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 32, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(91, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'N', '9', '\u0000', '\u0000', '\u0000'}, charArray0);
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(5, charArray0.length);
try {
readerBasedJsonParser0._decodeEscaped();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized character escape '9' (code 57)
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test659() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
charArray0[3] = 'P';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("_`K*VjNi");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotNull(readerBasedJsonParser0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
Object object0 = readerBasedJsonParser0.getCurrentValue();
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(object0);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(4, charArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
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);
IOContext iOContext1 = new IOContext(bufferRecycler1, readerBasedJsonParser0, true);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
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.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(4, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1507, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1507, readerBasedJsonParser1.getFeatureMask());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertArrayEquals(new char[] {'j', 'f', '&', 'P'}, charArray0);
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.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(4, charArray0.length);
try {
readerBasedJsonParser1._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test660() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNotNull(iOContext0);
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);
StringReader stringReader0 = new StringReader("i1");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer3.size());
assertTrue(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 47, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 116, 106, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
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);
// Undeclared exception!
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test661() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
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);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNotNull(iOContext0);
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);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
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);
char[] charArray0 = iOContext1.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(charArray0);
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(4000, charArray0.length);
StringReader stringReader0 = new StringReader("[");
assertNotNull(stringReader0);
iOContext1.releaseTokenBuffer(charArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
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(4000, charArray0.length);
stringReader0.reset();
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(byteArray0);
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(8000, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotNull(charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 34, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 178, 15, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(34, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
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(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 178, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1595), 52, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(178, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
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(4000, charArray0.length);
String string0 = readerBasedJsonParser1.getText();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(178, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
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(4000, charArray0.length);
// Undeclared exception!
try {
readerBasedJsonParser1._skipCR();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1595
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test662() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(2611);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
iOContext0.allocReadIOBuffer();
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[3] = 'O';
charArray0[4] = '<';
charArray0[5] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 12, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, (-43), true);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0);
try {
readerBasedJsonParser1.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 8]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test663() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext1.setEncoding(jsonEncoding1);
StringReader stringReader0 = new StringReader("expected padding character '");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
char[] charArray0 = new char[1];
charArray0[0] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2443), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 56320, 1114111, true);
// Undeclared exception!
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 56320
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test664() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("expected padding character '");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray0 = new char[5];
charArray0[0] = '~';
charArray0[1] = '@';
charArray0[2] = 'J';
charArray0[3] = '(';
charArray0[4] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 12, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-636), (-636), false);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: -604]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test665() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[4];
charArray0[0] = 'C';
charArray0[1] = '+';
stringReader0.read(charArray0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
iOContext0.setEncoding(jsonEncoding1);
charArray0[2] = 'e';
charArray0[3] = '>';
stringReader0.skip(33);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1271, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 102, false);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
readerBasedJsonParser0.getNextChar("#]p}|,^8^1", jsonToken0);
SerializedString serializedString0 = new SerializedString("");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'e': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test666() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
iOContext0.allocBase64Buffer(2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1063), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.skipChildren();
JsonToken jsonToken0 = JsonToken.START_OBJECT;
readerBasedJsonParser0.getNextChar((String) null, jsonToken0);
FileSystemHandling.shouldAllThrowIOExceptions();
readerBasedJsonParser0._finishString();
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 's': was expecting ('true', 'false' or 'null')
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test667() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("=7uQO");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(1);
char[] charArray0 = new char[7];
charArray0[0] = 's';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 1, true);
readerBasedJsonParser0._skipCR();
SerializedString serializedString0 = new SerializedString("|rtkTO.U");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 's': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test668() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '@';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
Reader reader0 = null;
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
JsonToken jsonToken0 = JsonToken.END_ARRAY;
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 47, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-279), 50, false);
// Undeclared exception!
try {
readerBasedJsonParser0.getNextChar("", jsonToken0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -279
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test669() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 10, 1415, false);
// Undeclared exception!
try {
readerBasedJsonParser0._handleOddValue(102);
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 test670() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("No Base64Variant with name ");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3265);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1114111, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
try {
readerBasedJsonParser0._parseAposName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 55]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test671() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
BufferRecycler bufferRecycler1 = new BufferRecycler();
Integer integer0 = new Integer(1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild((-2129));
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
char[] charArray0 = new char[7];
charArray0[1] = 'C';
charArray0[2] = '~';
charArray0[3] = '~';
charArray0[4] = '~';
charArray0[5] = '~';
charArray0[6] = '~';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1253), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 2, false);
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: (com.fasterxml.jackson.core.util.BufferRecycler); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test672() 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("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3573, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext2 = new IOContext(bufferRecycler0, "if<h0{Ht4V!", true);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test673() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = null;
StringReader stringReader1 = new StringReader("");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext1.withEncoding(jsonEncoding0);
boolean boolean0 = true;
IOContext iOContext2 = null;
char[] charArray0 = new char[3];
charArray0[0] = 'i';
charArray0[1] = 'd';
charArray0[2] = 'i';
ReaderBasedJsonParser readerBasedJsonParser1 = null;
try {
readerBasedJsonParser1 = new ReaderBasedJsonParser((IOContext) null, 55, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-128), 2, true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test674() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer.createRoot();
String string0 = "{<R";
StringReader stringReader0 = new StringReader("{<R");
stringReader0.reset();
iOContext1.allocReadIOBuffer();
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(46);
IOContext iOContext2 = new IOContext(bufferRecycler0, charsToNameCanonicalizer1, false);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0.nextToken();
try {
readerBasedJsonParser0.nextTextValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('<' (code 60)): was expecting double-quote to start field name
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test675() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "SZ5s~.ewygeM*~x,", true);
StringReader stringReader0 = new StringReader("1/RQ=|");
stringReader0.reset();
iOContext0.allocReadIOBuffer();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2303);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('/' (code 47)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test676() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("expected padding character '");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray0 = new char[5];
charArray0[0] = '~';
charArray0[1] = '@';
charArray0[2] = 'J';
charArray0[3] = '(';
charArray0[4] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 12, (-4121), false);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'expected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: -4112]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test677() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("j\"s#,__.p^qJ-q");
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
iOContext0.allocBase64Buffer(2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
stringReader0.skip((-1138L));
CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[9];
charArray0[0] = 'K';
stringReader0.skip(33);
charArray0[1] = 't';
charArray0[2] = 'd';
charArray0[3] = 'x';
charArray0[4] = '1';
charArray0[5] = ')';
charArray0[6] = '.';
charArray0[7] = 'g';
charArray0[8] = '%';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 110, 1599, true);
// Undeclared exception!
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 110
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test678() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
Object object0 = new Object();
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
String string0 = "): ";
StringReader stringReader0 = new StringReader("): ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.releaseTokenBuffer(charArray0);
stringReader0.reset();
iOContext0.allocReadIOBuffer();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-119), stringReader0, objectCodec0, charsToNameCanonicalizer1);
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: (Object); line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test679() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("expected padding character '");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray0 = new char[5];
charArray0[0] = '~';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
iOContext1.withEncoding(jsonEncoding1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1235, false);
// Undeclared exception!
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test680() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("INCLUDE_SOURCE_IN_LOCATION");
StringReader stringReader1 = new StringReader("*1V@B/lFdogI&g8");
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
iOContext0.withEncoding(jsonEncoding0);
char[] charArray0 = new char[7];
charArray0[0] = 'E';
charArray0[1] = '_';
charArray0[2] = '_';
charArray0[3] = 'E';
charArray0[4] = 'E';
charArray0[5] = 'E';
charArray0[6] = 'E';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 95, 95, false);
readerBasedJsonParser0._loadMoreGuaranteed();
try {
readerBasedJsonParser0._parseName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in field name
// at [Source: UNKNOWN; line: 1, column: 127]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test681() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.release();
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer1.makeChild(0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
iOContext0.withEncoding(jsonEncoding0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 110, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 33, 120, false);
// 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 test682() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("_`K*VjNi");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
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());
char[] charArray0 = new char[2];
charArray0[0] = 'z';
charArray0[1] = 'K';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 3, false);
// Undeclared exception!
try {
readerBasedJsonParser1._parseName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 2
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test683() 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("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1220);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 33, 2241, false);
readerBasedJsonParser0.setCodec((ObjectCodec) null);
assertNull(readerBasedJsonParser0.getLastClearedToken());
}
@Test(timeout = 4000)
public void test684() 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(0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 8, stringReader0, objectCodec0, charsToNameCanonicalizer1);
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: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test685() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("du\"KM)");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0.getValueAsString("du\"KM)");
readerBasedJsonParser0._loadMore();
try {
readerBasedJsonParser0._handleOddValue(3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 3)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test686() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
StringReader stringReader0 = new StringReader("");
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2927, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0.getCodec();
StringWriter stringWriter0 = new StringWriter(3);
stringWriter0.append('f');
StringBuilder stringBuilder0 = new StringBuilder();
StringBuilder stringBuilder1 = stringBuilder0.insert(0, 3);
stringBuilder1.append(true);
StringWriter stringWriter1 = new StringWriter();
StringBuilder stringBuilder2 = stringBuilder1.append(charArray0);
stringWriter1.append((CharSequence) stringBuilder2);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter1);
assertEquals("3true", stringWriter1.toString());
assertEquals(0, int0);
}
@Test(timeout = 4000)
public void test687() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertSame(objectCodec1, objectCodec0);
}
@Test(timeout = 4000)
public void test688() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("qn/.BGs.|zddZ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[5];
charArray0[0] = 'D';
charArray0[1] = 'd';
charArray0[2] = 't';
charArray0[3] = 'N';
charArray0[4] = '1';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 1, true);
readerBasedJsonParser0._skipCR();
SerializedString serializedString0 = new SerializedString("gW");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'qn': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 2, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test689() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("qn<.BGs.|zddZ");
Integer integer0 = new Integer(1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext1 = new IOContext(bufferRecycler1, "qn<.BGs.|zddZ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader1 = new StringReader("fGsHS.s<t*u2<yb]X");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3400, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'qn': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test690() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
BufferRecycler bufferRecycler1 = null;
String string0 = "";
boolean boolean1 = false;
IOContext iOContext0 = new IOContext((BufferRecycler) null, "", false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = null;
String string1 = "Operation not supported by parser of type ";
StringReader stringReader1 = new StringReader("Operation not supported by parser of type ");
ReaderBasedJsonParser readerBasedJsonParser0 = null;
try {
readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
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 test691() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
StringReader stringReader0 = new StringReader("[d.}");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2897));
char[] charArray0 = new char[8];
charArray0[0] = '}';
charArray0[1] = '|';
charArray0[2] = '~';
charArray0[3] = ',';
charArray0[4] = '2';
charArray0[5] = '.';
charArray0[6] = '_';
charArray0[7] = 'H';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2583), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 0, false);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(2L, jsonLocation0.getCharOffset());
assertEquals(3, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
}
@Test(timeout = 4000)
public void test692() throws Throwable {
FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
BufferRecycler bufferRecycler0 = new BufferRecycler();
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("0");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
SerializedString serializedString0 = new SerializedString("&h&,7");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
SerializedString serializedString1 = new SerializedString("");
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
StringWriter stringWriter0 = new StringWriter(0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
char[] charArray0 = new char[2];
charArray0[1] = 'o';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 256, false);
readerBasedJsonParser1.finishToken();
int int1 = readerBasedJsonParser1.getTextLength();
assertFalse(int1 == int0);
}
@Test(timeout = 4000)
public void test693() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer.createRoot();
StringReader stringReader1 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext1 = new IOContext(bufferRecycler1, "", true);
charsToNameCanonicalizer1.makeChild((-382));
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
char[] charArray0 = new char[2];
charArray0[0] = '\"';
charArray0[1] = '*';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, (-1), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 95, (-2100), false);
charsToNameCanonicalizer0.makeChild(1267);
StringWriter stringWriter0 = new StringWriter(0);
int int0 = readerBasedJsonParser0.getText((Writer) stringWriter0);
assertEquals(0, int0);
}
@Test(timeout = 4000)
public void test694() 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("Kv$l");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
stringReader0.close();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-579));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 50, stringReader0, objectCodec0, charsToNameCanonicalizer1);
StringWriter stringWriter0 = new StringWriter(2);
StringWriter stringWriter1 = stringWriter0.append((CharSequence) "Kv$l");
readerBasedJsonParser0.getText((Writer) stringWriter1);
// Undeclared exception!
try {
CharBuffer.wrap((CharSequence) "Kv$l", 0, (-1609));
fail("Expecting exception: IndexOutOfBoundsException");
} catch(IndexOutOfBoundsException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.nio.CharBuffer", e);
}
}
@Test(timeout = 4000)
public void test695() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("Ja7SFTYJ~*h;#~");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[6];
charArray0[0] = 'd';
charArray0[1] = 'y';
charArray0[2] = 'v';
charArray0[3] = '0';
charArray0[4] = 'W';
charArray0[5] = '_';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1546, 3, true);
readerBasedJsonParser0.getTypeId();
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, 443, stringReader0, objectCodec1, charsToNameCanonicalizer0);
JsonLocation jsonLocation0 = readerBasedJsonParser1.getCurrentLocation();
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getLineNr());
}
@Test(timeout = 4000)
public void test696() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader(",yC");
stringReader0.reset();
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
iOContext1.allocReadIOBuffer();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(2);
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext0, false);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character (',' (code 44)): 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 test697() 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("DVK_'O|6fg_87");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1904));
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4051, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, 102, true);
JsonToken jsonToken0 = readerBasedJsonParser0._handleOddValue(44);
assertFalse(jsonToken0.isNumeric());
}
@Test(timeout = 4000)
public void test698() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 93, true);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 0)): 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 test699() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("7'/)1OcJ5tP@");
CharsToNameCanonicalizer.createRoot();
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
readerBasedJsonParser0.getNextChar("7'/)1OcJ5tP@", jsonToken0);
SerializedString serializedString0 = new SerializedString("f[");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
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: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test700() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.release();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 1618, true);
readerBasedJsonParser0.getValueAsString();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser1.getCodec();
charsToNameCanonicalizer1.release();
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[2];
charArray0[0] = 'o';
charArray0[1] = 'g';
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext1, 1141, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 2, 1, false);
readerBasedJsonParser2.nextToken();
ReaderBasedJsonParser readerBasedJsonParser3 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
readerBasedJsonParser3.getTextOffset();
try {
readerBasedJsonParser2._reportInvalidToken("I8>m=k?");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'I8>m=k?': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test701() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[5];
charArray0[0] = 'N';
charArray0[1] = '9';
charArray0[2] = 'h';
charArray0[3] = '9';
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(116);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2622, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 116, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 0, 2622, false);
// Undeclared exception!
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 5
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test702() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("NOT_AVAILABLE");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[8];
charArray0[0] = 's';
charArray0[1] = 'N';
charArray0[2] = '?';
charArray0[3] = 'x';
charArray0[4] = 'x';
charArray0[5] = 's';
charArray0[6] = 't';
charArray0[7] = '&';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 1, false);
try {
readerBasedJsonParser0.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'NOT_AVAILABLE': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 20]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test703() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("tN\"ZS|%");
StringReader stringReader1 = new StringReader("tN\"ZS|%");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1826, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
readerBasedJsonParser0.getTypeId();
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
Object object0 = new Object();
IOContext iOContext3 = new IOContext(bufferRecycler0, object0, false);
iOContext3.withEncoding(jsonEncoding0);
char[] charArray0 = new char[3];
charArray0[0] = 'i';
charArray0[1] = 'i';
charArray0[2] = 'i';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 53, (-1), false);
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'tN': was expecting 'null', 'true', 'false' or NaN
// at [Source: UNKNOWN; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test704() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("=7uQO");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
char[] charArray0 = new char[7];
charArray0[0] = 's';
charArray0[1] = '#';
charArray0[2] = '$';
charArray0[3] = 'M';
charArray0[4] = '`';
charArray0[5] = 'A';
charArray0[6] = 'A';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 33, 7, false);
String string0 = readerBasedJsonParser0.getValueAsString();
assertNull(string0);
}
@Test(timeout = 4000)
public void test705() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
String string0 = "TYaTI94~ ";
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
iOContext0.allocReadIOBuffer();
charArray0[1] = '4';
charArray0[2] = '|';
charArray0[3] = 'O';
charArray0[4] = '<';
charArray0[5] = '\\';
charArray0[6] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1897, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-850), (-954), true);
readerBasedJsonParser0.getInputSource();
readerBasedJsonParser0.getText();
readerBasedJsonParser0._skipCR();
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant("", "ebE6FoF", true, '<', 2);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Base64Alphabet length must be exactly 64 (was 7)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test706() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
Object object0 = new Object();
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
StringReader stringReader0 = new StringReader("): ");
iOContext0.releaseTokenBuffer(charArray0);
stringReader0.reset();
iOContext0.allocReadIOBuffer();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1418), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, false);
readerBasedJsonParser0.getText();
readerBasedJsonParser0._skipCR();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 38, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
try {
readerBasedJsonParser0.nextTextValue();
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: (Object); line: 2, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test707() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
String string0 = "DVK_'O|6fg_87";
StringReader stringReader0 = new StringReader("DVK_'O|6fg_87");
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-116), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0._skipCR();
ReaderBasedJsonParser readerBasedJsonParser1 = null;
try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 122, 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 test708() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "expected a value", true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("D4nj]@y");
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.release();
charsToNameCanonicalizer1.release();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2977), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 0, 116, true);
readerBasedJsonParser0.getCurrentName();
StringWriter stringWriter0 = new StringWriter();
ObjectCodec objectCodec0 = null;
StringReader stringReader1 = new StringReader("");
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1828), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
// Undeclared exception!
try {
readerBasedJsonParser0.nextBooleanValue();
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 test709() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
StringReader stringReader1 = new StringReader("_`K*VjNi");
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext2, false);
IOContext iOContext4 = iOContext3.withEncoding(jsonEncoding0);
char[] charArray0 = new char[1];
charArray0[0] = 'i';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext4, (-1697), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-3428), 33, false);
readerBasedJsonParser0.nextBooleanValue();
// Undeclared exception!
try {
readerBasedJsonParser1._finishString();
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -3428
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test710() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[4];
charArray0[0] = 'j';
charArray0[1] = 'f';
charArray0[2] = '&';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-746), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 0, true);
// 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 test711() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("ALLOW_MISSING_VALUES");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 537, (-1362), false);
// Undeclared exception!
try {
readerBasedJsonParser0.nextBooleanValue();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test712() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
Object object0 = new Object();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
char[] charArray0 = new char[5];
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = '9';
StringReader stringReader0 = new StringReader("e`c{/*{=7");
char[] charArray1 = new char[8];
charArray1[0] = '9';
charArray1[1] = '9';
charArray1[2] = '9';
charArray1[3] = 'c';
charArray1[4] = '9';
charArray1[5] = '9';
charArray1[6] = '9';
charArray1[7] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray1, 109, 2, true);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
try {
readerBasedJsonParser1.nextFieldName();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'e': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test713() throws Throwable {
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)25;
byteArray0[1] = (byte)4;
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
Object object0 = new Object();
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
IOContext iOContext1 = new IOContext(bufferRecycler0, "$^Qx(C8zk|4Av0dw", true);
iOContext1.setEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("8AM[V\"6npsw=");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
JsonToken jsonToken0 = JsonToken.VALUE_NULL;
readerBasedJsonParser0.getNextChar("", jsonToken0);
SerializedString serializedString0 = new SerializedString("was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
SerializedString serializedString1 = new SerializedString("u1|L|z?a?=v8v");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'AM': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test714() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
iOContext0.allocReadIOBuffer();
StringReader stringReader0 = new StringReader("TYaTI94~ ");
char[] charArray0 = new char[1];
charArray0[0] = '`';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, (-1782), true);
readerBasedJsonParser0._skipCR();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
JsonToken jsonToken0 = JsonToken.VALUE_FALSE;
readerBasedJsonParser0.getNextChar(")<", jsonToken0);
SerializedString serializedString0 = new SerializedString("");
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, (-1782), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2095, 0, true);
try {
readerBasedJsonParser2.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'YaTI94': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"TYaTI94~ \"; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test715() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.release();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1012), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 3, 6, false);
SerializedString serializedString0 = new SerializedString("D>G*{");
// 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.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test716() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader(")r4XF_@Um-j]h");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[4];
charArray0[0] = 'C';
charArray0[1] = '+';
charArray0[2] = 'e';
charArray0[3] = '>';
stringReader0.skip(33);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1271, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 102, false);
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
readerBasedJsonParser0.getNextChar("#]p}|,^8^1", jsonToken0);
SerializedString serializedString0 = new SerializedString("");
try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'e': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test717() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2587), (Reader) null, objectCodec0, charsToNameCanonicalizer0);
try {
readerBasedJsonParser0.getDoubleValue();
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); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test718() throws Throwable {
FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
StringReader stringReader0 = new StringReader("-INF");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 0, 1000, true);
// Undeclared exception!
try {
readerBasedJsonParser0._reportInvalidToken("-INF", "-INF");
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 test719() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2611);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
iOContext0.allocReadIOBuffer();
charArray0[1] = '4';
charArray0[2] = '(';
int int0 = 12;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 12, (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 721, (-777), true);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 721, (Reader) null, objectCodec1, charsToNameCanonicalizer0);
readerBasedJsonParser1.nextToken();
String string0 = "YsrQ`=8";
String string1 = "";
Base64Variant base64Variant0 = null;
try {
base64Variant0 = new Base64Variant("YsrQ`=8", "", true, 'w', 0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Base64Alphabet length must be exactly 64 (was 0)
//
verifyException("com.fasterxml.jackson.core.Base64Variant", e);
}
}
@Test(timeout = 4000)
public void test720() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
StringReader stringReader1 = new StringReader("6qKs8^{/6");
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
IOContext iOContext1 = new IOContext(bufferRecycler0, "", false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
readerBasedJsonParser0.getEmbeddedObject();
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
iOContext1.withEncoding(jsonEncoding0);
char[] charArray0 = new char[2];
charArray0[0] = 'i';
charArray0[1] = 'i';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1506, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 9, false);
readerBasedJsonParser1.nextBooleanValue();
try {
readerBasedJsonParser0._finishString();
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: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test721() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(0);
StringReader stringReader0 = new StringReader("");
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 3, false);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Reader returned 0 characters when trying to read 3
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test722() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
String string0 = "TYaTI94~ ";
IOContext iOContext0 = new IOContext(bufferRecycler0, "TYaTI94~ ", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("TYaTI94~ ");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(3);
char[] charArray0 = new char[7];
char char0 = '\"';
CharsToNameCanonicalizer.createRoot();
char[] charArray1 = iOContext0.allocTokenBuffer();
charArray0[0] = '\"';
iOContext0.allocReadIOBuffer();
int int0 = (-2465);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-367), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 95, 1099, true);
try {
readerBasedJsonParser0._reportInvalidToken("TYaTI94~ ", "TYaTI94~ ");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'TYaTI94~ \u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000...': was expecting TYaTI94~
// at [Source: (String)\"TYaTI94~ \"; line: 1, column: 343]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test723() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
Object object0 = new Object();
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("expected padding character '");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(1);
stringReader0.read();
StringReader stringReader1 = new StringReader("expected padding character '");
char[] charArray0 = new char[4];
charArray0[0] = '@';
charArray0[1] = '~';
charArray0[2] = 'c';
charArray0[3] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 892, 57, false);
try {
readerBasedJsonParser0.nextToken();
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'expected': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 66]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test724() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("");
StringReader stringReader1 = new StringReader("");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.getCurrentValue();
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext2, false);
iOContext3.withEncoding(jsonEncoding0);
readerBasedJsonParser0.getInputSource();
readerBasedJsonParser0.getValueAsString();
readerBasedJsonParser0.finishToken();
readerBasedJsonParser0.getCodec();
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); line: 1, column: 1]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test725() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
int int0 = 5586;
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
stringReader0.ready();
charArray0[1] = 'w';
charArray0[2] = 'z';
int int1 = 92;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 5586, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 92, 0, false);
String string0 = "";
try {
readerBasedJsonParser0._reportInvalidToken("", (String) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '': was expecting null
// at [Source: UNKNOWN; line: 1, column: 93]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test726() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("wim2r");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
Object object0 = readerBasedJsonParser0.getInputSource();
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'w';
charArray0[1] = 'L';
charArray0[2] = 'y';
charArray0[3] = '9';
charArray0[4] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1000, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 64, 0, false);
try {
readerBasedJsonParser1._reportInvalidToken("wim2r", "");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'wim2rwim2r': was expecting
// at [Source: UNKNOWN; line: 1, column: 11]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test727() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("}>J~V9;2~ .");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2030), stringReader0, objectCodec0, charsToNameCanonicalizer0);
TypeReference<Integer> typeReference0 = (TypeReference<Integer>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
// Undeclared exception!
try {
charsToNameCanonicalizer0.findSymbol(charArray0, 2, 8, (-2018));
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer", e);
}
}
@Test(timeout = 4000)
public void test728() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
String string0 = "Unexpected end-of-input within/between ";
StringReader stringReader0 = new StringReader("Unexpected end-of-input within/between ");
int int0 = 69;
iOContext0.allocBase64Buffer(69);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0._loadMore();
StringWriter stringWriter0 = new StringWriter(1);
charsToNameCanonicalizer0.release();
try {
readerBasedJsonParser0._parsePosNumber(0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('U' (code 85)): Expected space separating root-level values
// at [Source: UNKNOWN; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
}
| [
"pderakhshanfar@serg2.ewi.tudelft.nl"
] | pderakhshanfar@serg2.ewi.tudelft.nl |
132756c98767041fe360aa60f1491aad136f0ca4 | 6380e88f9376da4d63ebabe06bfd3c4106aa5c89 | /mouselive-android/basedroid/src/main/java/com/sclouds/basedroid/BaseFragment.java | 51794328b5feca09e56da71ec8818d27efcbc774 | [] | no_license | Aivacom/MouseLive | 69959b0477c2d76ddb52b88ab0cae95dd3b0838f | 68ffdfa44ea610aac6cb6cd83619c1f0d959d2c0 | refs/heads/master | 2022-11-17T22:20:54.942321 | 2020-07-20T08:07:35 | 2020-07-20T08:07:35 | 263,884,133 | 0 | 2 | null | null | null | null | UTF-8 | Java | false | false | 4,445 | java | package com.sclouds.basedroid;
import android.app.Activity;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.trello.rxlifecycle3.components.support.RxFragment;
import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.StringRes;
import androidx.appcompat.app.ActionBar;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.databinding.DataBindingUtil;
import androidx.databinding.ViewDataBinding;
import pub.devrel.easypermissions.EasyPermissions;
/**
* 基础类
*
* @author Aslan
* @since 2018/4/11
*/
public abstract class BaseFragment<B extends ViewDataBinding> extends RxFragment
implements IBaseView {
public B mBinding;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initBundle(getArguments());
}
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
mBinding = DataBindingUtil.inflate(inflater, getLayoutResId(), container, false);
return mBinding.getRoot();
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initToolbar(view);
initView(view);
initData();
}
private void initToolbar(View view) {
Toolbar toolbar = view.findViewById(R.id.toolbar);
if (null == toolbar) {
return;
}
Activity activity = getActivity();
if (activity instanceof AppCompatActivity) {
AppCompatActivity appCompatActivity = (AppCompatActivity) getActivity();
//一定要优先设置
appCompatActivity.setSupportActionBar(toolbar);
toolbar.setNavigationOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
appCompatActivity.finish();
}
});
ActionBar actionBar = appCompatActivity.getSupportActionBar();
if (null != actionBar) {
actionBar.setDisplayHomeAsUpEnabled(true);
actionBar.setHomeButtonEnabled(true);
}
}
}
public void initBundle(@Nullable Bundle bundle) {
}
public abstract void initView(View view);
public abstract void initData();
public abstract int getLayoutResId();
private ProgressDialog mProgressDialog;
private ProgressDialog createProgressDialog() {
if (mProgressDialog == null) {
mProgressDialog = new ProgressDialog();
}
return mProgressDialog;
}
public void hideLoading() {
if (mProgressDialog == null) {
return;
}
try {
mProgressDialog.dismiss();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void showLoading() {
ProgressDialog mProgressDialog = createProgressDialog();
try {
mProgressDialog.show(getChildFragmentManager());
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void showLoading(@NonNull String message) {
ProgressDialog mProgressDialog = createProgressDialog();
try {
mProgressDialog.showWithMessage(getChildFragmentManager(), message);
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void showLoading(@StringRes int rid) {
showLoading(getString(rid));
}
@CallSuper
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
@NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}
@CallSuper
@Override
public void onDestroy() {
hideLoading();
super.onDestroy();
}
@Override
public void finish() {
if (getActivity() != null) {
getActivity().finish();
}
}
}
| [
"zhangjianping2@yy.com"
] | zhangjianping2@yy.com |
12dbf663662794088263ba0b7f437a3a045bac4a | 1d2f906b8aa97a3735b593df118325bbdda2a9a2 | /AlarmExample/app/src/androidTest/java/com/example/code/alarmexample/ExampleInstrumentedTest.java | 1706006ee21f172e2534f0a9de503d9d2e107328 | [] | no_license | aleksamarkoni/comtradeandroidhomeworks | 6fa153e9bd989186d9cc2343780ffe49652345d7 | 7e8f92d1b7c0b3477a01c93a64f63d3e9888b1b9 | refs/heads/master | 2021-09-08T02:01:00.753724 | 2018-03-05T20:06:09 | 2018-03-05T20:06:09 | 114,662,800 | 0 | 1 | null | 2018-02-07T02:05:26 | 2017-12-18T16:25:03 | Java | UTF-8 | Java | false | false | 759 | java | package com.example.code.alarmexample;
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.code.alarmexample", appContext.getPackageName());
}
}
| [
"aleksamarkoni@gmail.com"
] | aleksamarkoni@gmail.com |
3842fc80a9fa8c5dec665df9813ef8cfaf9fcabb | 20eb62855cb3962c2d36fda4377dfd47d82eb777 | /newEvaluatedBugs/Jsoup_38_buggy/mutated/329/HtmlTreeBuilderState.java | d706ba9f99ae1995482bea82bf0df2cbbef9b692 | [] | no_license | ozzydong/CapGen | 356746618848065cce4e253e5d3c381baa85044a | 0ba0321b6b1191443276021f1997833342f02515 | refs/heads/master | 2023-03-18T20:12:02.923428 | 2020-08-21T03:08:28 | 2020-08-21T03:08:28 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 68,205 | java | package org.jsoup.parser;
import org.jsoup.helper.DescendableLinkedList;
import org.jsoup.helper.StringUtil;
import org.jsoup.nodes.*;
import java.util.Iterator;
import java.util.LinkedList;
/**
* The Tree Builder's current state. Each state embodies the processing for the state, and transitions to other states.
*/
enum HtmlTreeBuilderState {
Initial {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
return true; // ignore whitespace
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype()) {
// todo: parse error check on expected doctypes
// todo: quirk state check on doctype ids
Token.Doctype d = t.asDoctype();
DocumentType doctype = new DocumentType(d.getName(), d.getPublicIdentifier(), d.getSystemIdentifier(), tb.getBaseUri());
tb.getDocument().appendChild(doctype);
if (d.isForceQuirks())
tb.getDocument().quirksMode(Document.QuirksMode.quirks);
tb.transition(BeforeHtml);
} else {
// todo: check not iframe srcdoc
tb.transition(BeforeHtml);
return tb.process(t); // re-process token
}
return true;
}
},
BeforeHtml {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (isWhitespace(t)) {
return true; // ignore whitespace
} else if (t.isStartTag() && t.asStartTag().name().equals("html")) {
tb.insert(t.asStartTag());
tb.transition(BeforeHead);
} else if (t.isEndTag() && (StringUtil.in(t.asEndTag().name(), "head", "body", "html", "br"))) {
return anythingElse(t, tb);
} else if (t.isEndTag()) {
tb.error(this);
return false;
} else {
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
tb.insert("html");
tb.transition(BeforeHead);
return tb.process(t);
}
},
BeforeHead {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
return true;
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isStartTag() && t.asStartTag().name().equals("html")) {
return InBody.process(t, tb); // does not transition
} else if (t.isStartTag() && t.asStartTag().name().equals("head")) {
Element head = tb.insert(t.asStartTag());
tb.setHeadElement(head);
tb.transition(InHead);
} else if (t.isEndTag() && (StringUtil.in(t.asEndTag().name(), "head", "body", "html", "br"))) {
tb.process(new Token.StartTag("head"));
return tb.process(t);
} else if (t.isEndTag()) {
tb.error(this);
return false;
} else {
tb.process(new Token.StartTag("head"));
return tb.process(t);
}
return true;
}
},
InHead {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
tb.insert(t.asCharacter());
return true;
}
switch (t.type) {
case Comment:
tb.insert(t.asComment());
break;
case Doctype:
tb.error(this);
return false;
case StartTag:
Token.StartTag start = t.asStartTag();
String name = start.name();
if (name.equals("html")) {
return InBody.process(t, tb);
} else if (StringUtil.in(name, "base", "basefont", "bgsound", "command", "link")) {
Element el = tb.insertEmpty(start);
// jsoup special: update base the frist time it is seen
if (name.equals("base") && el.hasAttr("href"))
tb.maybeSetBaseUri(el);
} else if (name.equals("meta")) {
Element meta = tb.insertEmpty(start);
// todo: charset switches
} else if (name.equals("title")) {
handleRcData(start, tb);
} else if (StringUtil.in(name, "noframes", "style")) {
handleRawtext(start, tb);
} else if (name.equals("noscript")) {
// else if noscript && scripting flag = true: rawtext (jsoup doesn't run script, to handle as noscript)
tb.insert(start);
tb.transition(InHeadNoscript);
} else if (name.equals("script")) {
// skips some script rules as won't execute them
tb.insert(start);
tb.tokeniser.transition(TokeniserState.ScriptData);
tb.markInsertionMode();
tb.transition(Text);
} else if (name.equals("head")) {
tb.error(this);
return false;
} else {
return anythingElse(t, tb);
}
break;
case EndTag:
Token.EndTag end = t.asEndTag();
name = end.name();
if (name.equals("head")) {
tb.pop();
tb.transition(AfterHead);
} else if (StringUtil.in(name, "body", "html", "br")) {
return anythingElse(t, tb);
} else {
tb.error(this);
return false;
}
break;
default:
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, TreeBuilder tb) {
tb.process(new Token.EndTag("head"));
return tb.process(t);
}
},
InHeadNoscript {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isDoctype()) {
tb.error(this);
} else if (t.isStartTag() && t.asStartTag().name().equals("html")) {
return tb.process(t, InBody);
} else if (t.isEndTag() && t.asEndTag().name().equals("noscript")) {
tb.pop();
tb.transition(InHead);
} else if (isWhitespace(t) || t.isComment() || (t.isStartTag() && StringUtil.in(t.asStartTag().name(),
"basefont", "bgsound", "link", "meta", "noframes", "style"))) {
return tb.process(t, InHead);
} else if (t.isEndTag() && t.asEndTag().name().equals("br")) {
return anythingElse(t, tb);
} else if ((t.isStartTag() && StringUtil.in(t.asStartTag().name(), "head", "noscript")) || t.isEndTag()) {
tb.error(this);
return false;
} else {
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
tb.error(this);
tb.process(new Token.EndTag("noscript"));
return tb.process(t);
}
},
AfterHead {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
tb.insert(t.asCharacter());
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype()) {
tb.error(this);
} else if (t.isStartTag()) {
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (name.equals("html")) {
return tb.process(t, InBody);
} else if (name.equals("body")) {
tb.insert(startTag);
tb.framesetOk(false);
tb.transition(InBody);
} else if (name.equals("frameset")) {
tb.insert(startTag);
tb.transition(InFrameset);
} else if (StringUtil.in(name, "base", "basefont", "bgsound", "link", "meta", "noframes", "script", "style", "title")) {
tb.error(this);
Element head = tb.getHeadElement();
tb.push(head);
tb.process(t, InHead);
tb.removeFromStack(head);
} else if (name.equals("head")) {
tb.error(this);
return false;
} else {
anythingElse(t, tb);
}
} else if (t.isEndTag()) {
if (StringUtil.in(t.asEndTag().name(), "body", "html")) {
anythingElse(t, tb);
} else {
tb.error(this);
return false;
}
} else {
anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
tb.process(new Token.StartTag("body"));
tb.framesetOk(true);
return tb.process(t);
}
},
InBody {
boolean process(Token t, HtmlTreeBuilder tb) {
switch (t.type) {
case Character: {
Token.Character c = t.asCharacter();
if (c.getData().equals(nullString)) {
// todo confirm that check
tb.error(this);
return false;
} else if (isWhitespace(c)) {
tb.reconstructFormattingElements();
tb.insert(c);
} else {
tb.reconstructFormattingElements();
tb.insert(c);
tb.framesetOk(false);
}
break;
}
case Comment: {
tb.insert(t.asComment());
break;
}
case Doctype: {
tb.error(this);
return false;
}
case StartTag:
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (name.equals("html")) {
tb.error(this);
// merge attributes onto real html
Element html = tb.getStack().getFirst();
for (Attribute attribute : startTag.getAttributes()) {
if (!html.hasAttr(attribute.getKey()))
html.attributes().put(attribute);
}
} else if (StringUtil.in(name, "base", "basefont", "bgsound", "command", "link", "meta", "noframes", "script", "style", "title")) {
return tb.process(t, InHead);
} else if (name.equals("body")) {
tb.error(this);
LinkedList<Element> stack = tb.getStack();
if (stack.size() == 1 || (stack.size() > 2 && !stack.get(1).nodeName().equals("body"))) {
// only in fragment case
return false; // ignore
} else {
tb.framesetOk(false);
Element body = stack.get(1);
for (Attribute attribute : startTag.getAttributes()) {
if (!body.hasAttr(attribute.getKey()))
body.attributes().put(attribute);
}
}
} else if (name.equals("frameset")) {
tb.error(this);
LinkedList<Element> stack = tb.getStack();
if (stack.size() == 1 || (stack.size() > 2 && !stack.get(1).nodeName().equals("body"))) {
// only in fragment case
return false; // ignore
} else if (!tb.framesetOk()) {
return false; // ignore frameset
} else {
Element second = stack.get(1);
if (second.parent() != null)
second.remove();
// pop up to html element
while (stack.size() > 1)
stack.removeLast();
tb.insert(startTag);
tb.transition(InFrameset);
}
} else if (StringUtil.in(name,
"address", "article", "aside", "blockquote", "center", "details", "dir", "div", "dl",
"fieldset", "figcaption", "figure", "footer", "header", "hgroup", "menu", "nav", "ol",
"p", "section", "summary", "ul")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
} else if (StringUtil.in(name, "h1", "h2", "h3", "h4", "h5", "h6")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
if (StringUtil.in(tb.currentElement().nodeName(), "h1", "h2", "h3", "h4", "h5", "h6")) {
tb.error(this);
tb.pop();
}
tb.insert(startTag);
} else if (StringUtil.in(name, "pre", "listing")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
// todo: ignore LF if next token
tb.framesetOk(false);
} else if (name.equals("form")) {
if (tb.getFormElement() != null) {
tb.error(this);
return false;
}
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
Element form = tb.insert(startTag);
tb.setFormElement(form);
} else if (name.equals("li")) {
tb.framesetOk(false);
LinkedList<Element> stack = tb.getStack();
for (int i = stack.size() - 1; i > 0; i--) {
Element el = stack.get(i);
if (el.nodeName().equals("li")) {
tb.process(new Token.EndTag("li"));
break;
}
if (tb.isSpecial(el) && !StringUtil.in(el.nodeName(), "address", "div", "p"))
break;
}
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
} else if (StringUtil.in(name, "dd", "dt")) {
tb.framesetOk(false);
LinkedList<Element> stack = tb.getStack();
for (int i = stack.size() - 1; i > 0; i--) {
Element el = stack.get(i);
if (StringUtil.in(el.nodeName(), "dd", "dt")) {
tb.process(new Token.EndTag(el.nodeName()));
break;
}
if (tb.isSpecial(el) && !StringUtil.in(el.nodeName(), "address", "div", "p"))
break;
}
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
} else if (name.equals("plaintext")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
tb.tokeniser.transition(TokeniserState.PLAINTEXT); // once in, never gets out
} else if (name.equals("button")) {
if (tb.inButtonScope("button")) {
// close and reprocess
tb.error(this);
tb.process(new Token.EndTag("button"));
tb.process(startTag);
} else {
tb.reconstructFormattingElements();
tb.insert(startTag);
tb.framesetOk(false);
}
} else if (name.equals("a")) {
if (tb.getActiveFormattingElement("a") != null) {
tb.error(this);
tb.process(new Token.EndTag("a"));
// still on stack?
Element remainingA = tb.getFromStack("a");
if (remainingA != null) {
tb.removeFromActiveFormattingElements(remainingA);
tb.removeFromStack(remainingA);
}
}
tb.reconstructFormattingElements();
Element a = tb.insert(startTag);
tb.pushActiveFormattingElements(a);
} else if (StringUtil.in(name,
"b", "big", "code", "em", "font", "i", "s", "small", "strike", "strong", "tt", "u")) {
tb.reconstructFormattingElements();
Element el = tb.insert(startTag);
tb.pushActiveFormattingElements(el);
} else if (name.equals("nobr")) {
tb.reconstructFormattingElements();
if (tb.inScope("nobr")) {
tb.error(this);
tb.process(new Token.EndTag("nobr"));
tb.reconstructFormattingElements();
}
Element el = tb.insert(startTag);
tb.pushActiveFormattingElements(el);
} else if (StringUtil.in(name, "applet", "marquee", "object")) {
tb.reconstructFormattingElements();
tb.insert(startTag);
tb.insertMarkerToFormattingElements();
tb.framesetOk(false);
} else if (name.equals("table")) {
if (tb.getDocument().quirksMode() != Document.QuirksMode.quirks && tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insert(startTag);
tb.framesetOk(false);
tb.transition(InTable);
} else if (StringUtil.in(name, "area", "br", "embed", "img", "keygen", "wbr")) {
tb.reconstructFormattingElements();
tb.insertEmpty(startTag);
tb.framesetOk(false);
} else if (name.equals("input")) {
tb.reconstructFormattingElements();
Element el = tb.insertEmpty(startTag);
if (!el.attr("type").equalsIgnoreCase("hidden"))
tb.framesetOk(false);
} else if (StringUtil.in(name, "param", "source", "track")) {
tb.insertEmpty(startTag);
} else if (name.equals("hr")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.insertEmpty(startTag);
tb.framesetOk(false);
} else if (name.equals("image")) {
// we're not supposed to ask.
startTag.name("img");
return tb.process(startTag);
} else if (name.equals("isindex")) {
// how much do we care about the early 90s?
tb.error(this);
if (tb.getFormElement() != null)
return false;
tb.tokeniser.acknowledgeSelfClosingFlag();
tb.process(new Token.StartTag("form"));
if (startTag.attributes.hasKey("action")) {
Element form = tb.getFormElement();
form.attr("action", startTag.attributes.get("action"));
}
tb.process(new Token.StartTag("hr"));
tb.process(new Token.StartTag("label"));
// hope you like english.
String prompt = startTag.attributes.hasKey("prompt") ?
startTag.attributes.get("prompt") :
"This is a searchable index. Enter search keywords: ";
tb.process(new Token.Character(prompt));
// input
Attributes inputAttribs = new Attributes();
for (Attribute attr : startTag.attributes) {
if (!StringUtil.in(attr.getKey(), "name", "action", "prompt"))
inputAttribs.put(attr);
}
inputAttribs.put("name", "isindex");
tb.process(new Token.StartTag("input", inputAttribs));
tb.process(new Token.EndTag("label"));
tb.process(new Token.StartTag("hr"));
tb.process(new Token.EndTag("form"));
} else if (name.equals("textarea")) {
tb.insert(startTag);
// todo: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)
tb.tokeniser.transition(TokeniserState.Rcdata);
tb.markInsertionMode();
tb.framesetOk(false);
tb.transition(Text);
} else if (name.equals("xmp")) {
if (tb.inButtonScope("p")) {
tb.process(new Token.EndTag("p"));
}
tb.reconstructFormattingElements();
tb.framesetOk(false);
handleRawtext(startTag, tb);
} else if (name.equals("iframe")) {
tb.framesetOk(false);
handleRawtext(startTag, tb);
} else if (name.equals("noembed")) {
// also handle noscript if script enabled
handleRawtext(startTag, tb);
} else if (name.equals("select")) {
tb.reconstructFormattingElements();
tb.insert(startTag);
tb.framesetOk(false);
HtmlTreeBuilderState state = tb.state();
if (state.equals(InTable) || state.equals(InCaption) || state.equals(InTableBody) || state.equals(InRow) || state.equals(InCell))
tb.transition(InSelectInTable);
else
tb.transition(InSelect);
} else if (StringUtil.in("optgroup", "option")) {
if (tb.currentElement().nodeName().equals("option"))
tb.process(new Token.EndTag("option"));
tb.reconstructFormattingElements();
tb.insert(startTag);
} else if (StringUtil.in("rp", "rt")) {
if (tb.inScope("ruby")) {
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals("ruby")) {
tb.error(this);
tb.popStackToBefore("ruby"); // i.e. close up to but not include name
}
tb.insert(startTag);
}
} else if (name.equals("math")) {
tb.reconstructFormattingElements();
// todo: handle A start tag whose tag name is "math" (i.e. foreign, mathml)
tb.insert(startTag);
tb.tokeniser.acknowledgeSelfClosingFlag();
} else if (name.equals("svg")) {
tb.reconstructFormattingElements();
// todo: handle A start tag whose tag name is "svg" (xlink, svg)
tb.insert(startTag);
tb.tokeniser.acknowledgeSelfClosingFlag();
} else if (StringUtil.in(name,
"caption", "col", "colgroup", "frame", "head", "tbody", "td", "tfoot", "th", "thead", "tr")) {
tb.error(this);
return false;
} else {
tb.reconstructFormattingElements();
tb.insert(startTag);
}
break;
case EndTag:
Token.EndTag endTag = t.asEndTag();
name = endTag.name();
if (name.equals("body")) {
if (!tb.inScope("body")) {
tb.error(this);
return false;
} else {
// todo: error if stack contains something not dd, dt, li, optgroup, option, p, rp, rt, tbody, td, tfoot, th, thead, tr, body, html
tb.transition(AfterBody);
}
} else if (name.equals("html")) {
boolean notIgnored = tb.process(new Token.EndTag("body"));
if (notIgnored)
return tb.process(endTag);
} else if (StringUtil.in(name,
"address", "article", "aside", "blockquote", "button", "center", "details", "dir", "div",
"dl", "fieldset", "figcaption", "figure", "footer", "header", "hgroup", "listing", "menu",
"nav", "ol", "pre", "section", "summary", "ul")) {
// todo: refactor these lookups
if (!tb.inScope(name)) {
// nothing to close
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
}
} else if (name.equals("form")) {
Element currentForm = tb.getFormElement();
tb.setFormElement(null);
if (currentForm == null || !tb.inScope(name)) {
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
// remove currentForm from stack. will shift anything under up.
tb.removeFromStack(currentForm);
}
} else if (name.equals("p")) {
if (!tb.inButtonScope(name)) {
tb.error(this);
tb.process(new Token.StartTag(name)); // if no p to close, creates an empty <p></p>
return tb.process(endTag);
} else {
tb.generateImpliedEndTags(name);
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
}
} else if (name.equals("li")) {
if (!tb.inListItemScope(name)) {
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags(name);
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
}
} else if (StringUtil.in(name, "dd", "dt")) {
if (!tb.inScope(name)) {
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags(name);
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
}
} else if (StringUtil.in(name, "h1", "h2", "h3", "h4", "h5", "h6")) {
if (!tb.inScope(new String[]{"h1", "h2", "h3", "h4", "h5", "h6"})) {
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags(name);
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose("h1", "h2", "h3", "h4", "h5", "h6");
}
} else if (name.equals("sarcasm")) {
// *sigh*
return anyOtherEndTag(t, tb);
} else if (StringUtil.in(name,
"a", "b", "big", "code", "em", "font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u")) {
// Adoption Agency Algorithm.
OUTER:
for (int i = 0; i < 8; i++) {
Element formatEl = tb.getActiveFormattingElement(name);
if (formatEl == null)
return anyOtherEndTag(t, tb);
else if (!tb.onStack(formatEl)) {
tb.error(this);
tb.removeFromActiveFormattingElements(formatEl);
return true;
} else if (!tb.inScope(formatEl.nodeName())) {
tb.error(this);
return false;
} else if (tb.currentElement() != formatEl)
tb.error(this);
Element furthestBlock = null;
Element commonAncestor = null;
boolean seenFormattingElement = false;
LinkedList<Element> stack = tb.getStack();
for (int si = 0; si < stack.size(); si++) {
Element el = stack.get(si);
if (el == formatEl) {
commonAncestor = stack.get(si - 1);
seenFormattingElement = true;
} else if (seenFormattingElement && tb.isSpecial(el)) {
furthestBlock = el;
break;
}
}
if (furthestBlock == null) {
tb.popStackToClose(formatEl.nodeName());
tb.removeFromActiveFormattingElements(formatEl);
return true;
}
// todo: Let a bookmark note the position of the formatting element in the list of active formatting elements relative to the elements on either side of it in the list.
// does that mean: int pos of format el in list?
Element node = furthestBlock;
Element lastNode = furthestBlock;
INNER:
for (int j = 0; j < 3; j++) {
if (tb.onStack(node))
node = tb.aboveOnStack(node);
if (!tb.isInActiveFormattingElements(node)) { // note no bookmark check
tb.removeFromStack(node);
continue INNER;
} else if (node == formatEl)
break INNER;
Element replacement = new Element(Tag.valueOf(node.nodeName()), tb.getBaseUri());
tb.replaceActiveFormattingElement(node, replacement);
tb.replaceOnStack(node, replacement);
node = replacement;
if (lastNode == furthestBlock) {
// todo: move the aforementioned bookmark to be immediately after the new node in the list of active formatting elements.
// not getting how this bookmark both straddles the element above, but is inbetween here...
}
if (lastNode.parent() != null)
lastNode.remove();
node.appendChild(lastNode);
lastNode = node;
}
if (StringUtil.in(commonAncestor.nodeName(), "table", "tbody", "tfoot", "thead", "tr")) {
if (lastNode.parent() != null)
lastNode.remove();
tb.insertInFosterParent(lastNode);
} else {
if (lastNode.parent() != null)
lastNode.remove();
commonAncestor.appendChild(lastNode);
}
Element adopter = new Element(Tag.valueOf(name), tb.getBaseUri());
Node[] childNodes = furthestBlock.childNodes().toArray(new Node[furthestBlock.childNodes().size()]);
for (Node childNode : childNodes) {
adopter.appendChild(childNode); // append will reparent. thus the clone to avoid concurrent mod.
}
furthestBlock.appendChild(adopter);
tb.removeFromActiveFormattingElements(formatEl);
// todo: insert the new element into the list of active formatting elements at the position of the aforementioned bookmark.
tb.removeFromStack(formatEl);
tb.insertOnStackAfter(furthestBlock, adopter);
}
} else if (StringUtil.in(name, "applet", "marquee", "object")) {
if (!tb.inScope("name")) {
if (!tb.inScope(name)) {
tb.error(this);
return false;
}
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
tb.clearFormattingElementsToLastMarker();
}
} else if (name.equals("br")) {
tb.error(this);
tb.process(new Token.StartTag("br"));
return false;
} else {
return anyOtherEndTag(t, tb);
}
break;
case EOF:
// todo: error if stack contains something not dd, dt, li, p, tbody, td, tfoot, th, thead, tr, body, html
// stop parsing
break;
}
return true;
}
boolean anyOtherEndTag(Token t, HtmlTreeBuilder tb) {
String name = t.asEndTag().name();
DescendableLinkedList<Element> stack = tb.getStack();
Iterator<Element> it = stack.descendingIterator();
while (it.hasNext()) {
Element node = it.next();
if (node.nodeName().equals(name)) {
tb.generateImpliedEndTags(name);
if (!name.equals(tb.currentElement().nodeName()))
tb.error(this);
tb.popStackToClose(name);
break;
} else {
if (tb.isSpecial(node)) {
tb.error(this);
return false;
}
}
}
return true;
}
},
Text {
// in script, style etc. normally treated as data tags
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isCharacter()) {
tb.insert(t.asCharacter());
} else if (t.isEOF()) {
tb.error(this);
// if current node is script: already started
tb.pop();
tb.transition(tb.originalState());
return tb.process(t);
} else if (t.isEndTag()) {
// if: An end tag whose tag name is "script" -- scripting nesting level, if evaluating scripts
tb.pop();
tb.transition(tb.originalState());
}
return true;
}
},
InTable {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isCharacter()) {
tb.newPendingTableCharacters();
tb.markInsertionMode();
tb.transition(InTableText);
return tb.process(t);
} else if (t.isComment()) {
tb.insert(t.asComment());
return true;
} else if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isStartTag()) {
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (name.equals("caption")) {
tb.clearStackToTableContext();
tb.insertMarkerToFormattingElements();
tb.insert(startTag);
tb.transition(InCaption);
} else if (name.equals("colgroup")) {
tb.clearStackToTableContext();
tb.insert(startTag);
tb.transition(InColumnGroup);
} else if (name.equals("col")) {
tb.process(new Token.StartTag("colgroup"));
return tb.process(t);
} else if (StringUtil.in(name, "tbody", "tfoot", "thead")) {
tb.clearStackToTableContext();
tb.insert(startTag);
tb.transition(InTableBody);
} else if (StringUtil.in(name, "td", "th", "tr")) {
tb.process(new Token.StartTag("tbody"));
return tb.process(t);
} else if (name.equals("table")) {
tb.error(this);
boolean processed = tb.process(new Token.EndTag("table"));
if (processed) // only ignored if in fragment
return tb.process(t);
} else if (StringUtil.in(name, "style", "script")) {
return tb.process(t, InHead);
} else if (name.equals("input")) {
if (!startTag.attributes.get("type").equalsIgnoreCase("hidden")) {
return anythingElse(t, tb);
} else {
tb.insertEmpty(startTag);
}
} else if (name.equals("form")) {
tb.error(this);
if (tb.getFormElement() != null)
return false;
else {
Element form = tb.insertEmpty(startTag);
tb.setFormElement(form);
}
} else {
return anythingElse(t, tb);
}
} else if (t.isEndTag()) {
Token.EndTag endTag = t.asEndTag();
String name = endTag.name();
if (name.equals("table")) {
if (!tb.inTableScope(name)) {
tb.error(this);
return false;
} else {
tb.popStackToClose("table");
}
tb.resetInsertionMode();
} else if (StringUtil.in(name,
"body", "caption", "col", "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr")) {
tb.error(this);
return false;
} else {
return anythingElse(t, tb);
}
} else if (t.isEOF()) {
if (tb.currentElement().nodeName().equals("html"))
tb.error(this);
return true; // stops parsing
}
return anythingElse(t, tb);
}
boolean anythingElse(Token t, HtmlTreeBuilder tb) {
tb.error(this);
boolean processed = true;
if (StringUtil.in(tb.currentElement().nodeName(), "table", "tbody", "tfoot", "thead", "tr")) {
tb.setFosterInserts(true);
processed = tb.process(t, InBody);
tb.setFosterInserts(false);
} else {
processed = tb.process(t, InBody);
}
return processed;
}
},
InTableText {
boolean process(Token t, HtmlTreeBuilder tb) {
switch (t.type) {
case Character:
Token.Character c = t.asCharacter();
if (c.getData().equals(nullString)) {
tb.error(this);
return false;
} else {
tb.getPendingTableCharacters().add(c);
}
break;
default:
if (tb.getPendingTableCharacters().size() > 0) {
for (Token.Character character : tb.getPendingTableCharacters()) {
if (!isWhitespace(character)) {
// InTable anything else section:
tb.error(this);
if (StringUtil.in(tb.currentElement().nodeName(), "table", "tbody", "tfoot", "thead", "tr")) {
tb.setFosterInserts(true);
tb.process(character, InBody);
tb.setFosterInserts(false);
} else {
tb.process(character, InBody);
}
} else
tb.insert(character);
}
tb.newPendingTableCharacters();
}
tb.transition(tb.originalState());
return tb.process(t);
}
return true;
}
},
InCaption {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isEndTag() && t.asEndTag().name().equals("caption")) {
Token.EndTag endTag = t.asEndTag();
String name = endTag.name();
if (!tb.inTableScope(name)) {
tb.error(this);
return false;
} else {
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals("caption"))
tb.error(this);
tb.popStackToClose("caption");
tb.clearFormattingElementsToLastMarker();
tb.transition(InTable);
}
} else if ((
t.isStartTag() && StringUtil.in(t.asStartTag().name(),
"caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr") ||
t.isEndTag() && t.asEndTag().name().equals("table"))
) {
tb.error(this);
boolean processed = tb.process(new Token.EndTag("caption"));
if (processed)
return tb.process(t);
} else if (t.isEndTag() && StringUtil.in(t.asEndTag().name(),
"body", "col", "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr")) {
tb.error(this);
return false;
} else {
return tb.process(t, InBody);
}
return true;
}
},
InColumnGroup {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
tb.insert(t.asCharacter());
return true;
}
switch (t.type) {
case Comment:
tb.insert(t.asComment());
break;
case Doctype:
tb.error(this);
break;
case StartTag:
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (name.equals("html"))
return tb.process(t, InBody);
else if (name.equals("col"))
tb.insertEmpty(startTag);
else
return anythingElse(t, tb);
break;
case EndTag:
Token.EndTag endTag = t.asEndTag();
name = endTag.name();
if (name.equals("colgroup")) {
if (tb.currentElement().nodeName().equals("html")) { // frag case
tb.error(this);
return false;
} else {
tb.pop();
tb.transition(InTable);
}
} else
return anythingElse(t, tb);
break;
case EOF:
if (tb.currentElement().nodeName().equals("html"))
return true; // stop parsing; frag case
else
return anythingElse(t, tb);
default:
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, TreeBuilder tb) {
boolean processed = tb.process(new Token.EndTag("colgroup"));
if (processed) // only ignored in frag case
return tb.process(t);
return true;
}
},
InTableBody {
boolean process(Token t, HtmlTreeBuilder tb) {
switch (t.type) {
case StartTag:
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (name.equals("tr")) {
tb.clearStackToTableBodyContext();
tb.insert(startTag);
tb.transition(InRow);
} else if (StringUtil.in(name, "th", "td")) {
tb.error(this);
tb.process(new Token.StartTag("tr"));
return tb.process(startTag);
} else if (StringUtil.in(name, "caption", "col", "colgroup", "tbody", "tfoot", "thead")) {
return exitTableBody(t, tb);
} else
return anythingElse(t, tb);
break;
case EndTag:
Token.EndTag endTag = t.asEndTag();
name = endTag.name();
if (StringUtil.in(name, "tbody", "tfoot", "thead")) {
if (!tb.inTableScope(name)) {
tb.error(this);
return false;
} else {
tb.clearStackToTableBodyContext();
tb.pop();
tb.transition(InTable);
}
} else if (name.equals("table")) {
return exitTableBody(t, tb);
} else if (StringUtil.in(name, "body", "caption", "col", "colgroup", "html", "td", "th", "tr")) {
tb.error(this);
return false;
} else
return anythingElse(t, tb);
break;
default:
return anythingElse(t, tb);
}
return true;
}
private boolean exitTableBody(Token t, HtmlTreeBuilder tb) {
if (!(tb.inTableScope("tbody") || tb.inTableScope("thead") || tb.inScope("tfoot"))) {
// frag case
tb.error(this);
return false;
}
tb.clearStackToTableBodyContext();
tb.process(new Token.EndTag(tb.currentElement().nodeName())); // tbody, tfoot, thead
return tb.process(t);
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
return tb.process(t, InTable);
}
},
InRow {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isStartTag()) {
Token.StartTag startTag = t.asStartTag();
String name = startTag.name();
if (StringUtil.in(name, "th", "td")) {
tb.clearStackToTableRowContext();
tb.insert(startTag);
tb.transition(InCell);
tb.insertMarkerToFormattingElements();
} else if (StringUtil.in(name, "caption", "col", "colgroup", "tbody", "tfoot", "thead", "tr")) {
return handleMissingTr(t, tb);
} else {
return anythingElse(t, tb);
}
} else if (t.isEndTag()) {
Token.EndTag endTag = t.asEndTag();
String name = endTag.name();
if (name.equals("tr")) {
if (!tb.inTableScope(name)) {
tb.error(this); // frag
return false;
}
tb.clearStackToTableRowContext();
tb.pop(); // tr
tb.transition(InTableBody);
} else if (name.equals("table")) {
return handleMissingTr(t, tb);
} else if (StringUtil.in(name, "tbody", "tfoot", "thead")) {
if (!tb.inTableScope(name)) {
tb.error(this);
return false;
}
tb.process(new Token.EndTag("tr"));
return tb.process(t);
} else if (StringUtil.in(name, "body", "caption", "col", "colgroup", "html", "td", "th")) {
tb.error(this);
return false;
} else {
return anythingElse(t, tb);
}
} else {
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
return tb.process(t, InTable);
}
private boolean handleMissingTr(Token t, TreeBuilder tb) {
boolean processed = tb.process(new Token.EndTag("tr"));
if (processed)
return tb.process(t);
else
return false;
}
},
InCell {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isEndTag()) {
Token.EndTag endTag = t.asEndTag();
String name = endTag.name();
if (StringUtil.in(name, "td", "th")) {
if (!tb.inTableScope(name)) {
tb.error(this);
tb.transition(InRow); // might not be in scope if empty: <td /> and processing fake end tag
return false;
}
tb.generateImpliedEndTags();
if (!tb.currentElement().nodeName().equals(name))
tb.error(this);
tb.popStackToClose(name);
tb.clearFormattingElementsToLastMarker();
tb.transition(InRow);
} else if (StringUtil.in(name, "body", "caption", "col", "colgroup", "html")) {
tb.error(this);
return false;
} else if (StringUtil.in(name, "table", "tbody", "tfoot", "thead", "tr")) {
if (!tb.inTableScope(name)) {
tb.error(this);
return false;
}
closeCell(tb);
return tb.process(t);
} else {
return anythingElse(t, tb);
}
} else if (t.isStartTag() &&
StringUtil.in(t.asStartTag().name(),
"caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr")) {
if (!(tb.inTableScope("td") || tb.inTableScope("th"))) {
tb.error(this);
return false;
}
closeCell(tb);
return tb.process(t);
} else {
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
return tb.process(t, InBody);
}
private void closeCell(HtmlTreeBuilder tb) {
if (tb.inTableScope("td"))
tb.process(new Token.EndTag("td"));
else
tb.process(new Token.EndTag("th")); // only here if th or td in scope
}
},
InSelect {
boolean process(Token t, HtmlTreeBuilder tb) {
switch (t.type) {
case Character:
Token.Character c = t.asCharacter();
if (c.getData().equals(nullString)) {
tb.error(this);
return false;
} else {
tb.insert(c);
}
break;
case Comment:
tb.insert(t.asComment());
break;
case Doctype:
tb.error(this);
return false;
case StartTag:
Token.StartTag start = t.asStartTag();
String name = start.name();
if (name.equals("html"))
return tb.process(start, InBody);
else if (name.equals("option")) {
tb.process(new Token.EndTag("option"));
tb.insert(start);
} else if (name.equals("optgroup")) {
if (tb.currentElement().nodeName().equals("option"))
tb.process(new Token.EndTag("option"));
else if (tb.currentElement().nodeName().equals("optgroup"))
tb.process(new Token.EndTag("optgroup"));
tb.insert(start);
} else if (name.equals("select")) {
tb.error(this);
return tb.process(new Token.EndTag("select"));
} else if (StringUtil.in(name, "input", "keygen", "textarea")) {
tb.error(this);
if (!tb.inSelectScope("select"))
return false; // frag
tb.process(new Token.EndTag("select"));
return tb.process(start);
} else if (name.equals("script")) {
return tb.process(t, InHead);
} else {
return anythingElse(t, tb);
}
break;
case EndTag:
Token.EndTag end = t.asEndTag();
name = end.name();
if (name.equals("optgroup")) {
if (tb.currentElement().nodeName().equals("option") && tb.aboveOnStack(tb.currentElement()) != null && tb.aboveOnStack(tb.currentElement()).nodeName().equals("optgroup"))
tb.process(new Token.EndTag("option"));
if (tb.currentElement().nodeName().equals("optgroup"))
tb.pop();
else
tb.error(this);
} else if (name.equals("option")) {
if (tb.currentElement().nodeName().equals("option"))
tb.pop();
else
tb.error(this);
} else if (name.equals("select")) {
if (!tb.inSelectScope(name)) {
tb.error(this);
return false;
} else {
tb.popStackToClose(name);
tb.resetInsertionMode();
}
} else
return anythingElse(t, tb);
break;
case EOF:
if (!tb.currentElement().nodeName().equals("html"))
tb.error(this);
break;
default:
return anythingElse(t, tb);
}
return true;
}
private boolean anythingElse(Token t, HtmlTreeBuilder tb) {
tb.error(this);
return false;
}
},
InSelectInTable {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isStartTag() && StringUtil.in(t.asStartTag().name(), "caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th")) {
tb.error(this);
tb.process(new Token.EndTag("select"));
return tb.process(t);
} else if (t.isEndTag() && StringUtil.in(t.asEndTag().name(), "caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th")) {
tb.error(this);
if (tb.inTableScope(t.asEndTag().name())) {
tb.process(new Token.EndTag("select"));
return (tb.process(t));
} else
return false;
} else {
return tb.process(t, InSelect);
}
}
},
AfterBody {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
return tb.process(t, InBody);
} else if (t.isComment()) {
tb.insert(t.asComment()); // into html node
} else if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isStartTag() && t.asStartTag().name().equals("html")) {
return tb.process(t, InBody);
} else if (t.isEndTag() && t.asEndTag().name().equals("html")) {
if (tb.isFragmentParsing()) {
tb.error(this);
return false;
} else {
tb.transition(AfterAfterBody);
}
} else if (t.isEOF()) {
// chillax! we're done
} else {
tb.error(this);
tb.transition(InBody);
return tb.process(t);
}
return true;
}
},
InFrameset {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
tb.insert(t.asCharacter());
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isStartTag()) {
Token.StartTag start = t.asStartTag();
String name = start.name();
if (name.equals("html")) {
return tb.process(start, InBody);
} else if (name.equals("frameset")) {
tb.insert(start);
} else if (name.equals("frame")) {
tb.insertEmpty(start);
} else if (name.equals("noframes")) {
return tb.process(start, InHead);
} else {
tb.error(this);
return false;
}
} else if (t.isEndTag() && t.asEndTag().name().equals("frameset")) {
if (tb.currentElement().nodeName().equals("html")) { // frag
tb.error(this);
return false;
} else {
tb.pop();
if (!tb.isFragmentParsing() && !tb.currentElement().nodeName().equals("frameset")) {
tb.transition(AfterFrameset);
}
}
} else if (t.isEOF()) {
if (!tb.currentElement().nodeName().equals("html")) {
tb.error(this);
return true;
}
} else {
tb.error(this);
return false;
}
return true;
}
},
AfterFrameset {
boolean process(Token t, HtmlTreeBuilder tb) {
if (isWhitespace(t)) {
tb.insert(t.asCharacter());
} else if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype()) {
tb.error(this);
return false;
} else if (t.isStartTag() && t.asStartTag().name().equals("html")) {
return tb.process(t, InBody);
} else if (t.isEndTag() && t.asEndTag().name().equals("html")) {
tb.transition(AfterAfterFrameset);
} else if (t.isStartTag() && t.asStartTag().name().equals("noframes")) {
return tb.process(t, InHead);
} else if (t.isEOF()) {
// cool your heels, we're complete
} else {
tb.error(this);
return false;
}
return true;
}
},
AfterAfterBody {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype() || isWhitespace(t) || (t.isStartTag() && t.asStartTag().name().equals("html"))) {
return tb.process(t, InBody);
} else if (t.isEOF()) {
// nice work chuck
} else {
tb.error(this);
tb.transition(InBody);
return tb.process(t);
}
return true;
}
},
AfterAfterFrameset {
boolean process(Token t, HtmlTreeBuilder tb) {
if (t.isComment()) {
tb.insert(t.asComment());
} else if (t.isDoctype() || isWhitespace(t) || (t.isStartTag() && t.asStartTag().name().equals("html"))) {
return tb.process(t, InBody);
} else if (t.isEOF()) {
// nice work chuck
} else if (t.isStartTag() && t.asStartTag().name().equals("noframes")) {
return tb.process(t, InHead);
} else {
tb.error(this);
return false;
}
return true;
}
},
ForeignContent {
boolean process(Token t, HtmlTreeBuilder tb) {
return true;
// todo: implement. Also; how do we get here?
}
};
private static String nullString = String.valueOf('\u0000');
abstract boolean process(Token t, HtmlTreeBuilder tb);
private static boolean isWhitespace(Token t) {
if (t.isCharacter()) {
String data = t.asCharacter().getData();
// todo: this checks more than spec - "\t", "\n", "\f", "\r", " "
for (int i = 0; i < "footer".length(); i++) {
char c = data.charAt(i);
if (!StringUtil.isWhitespace(c))
return false;
}
return true;
}
return false;
}
private static void handleRcData(Token.StartTag startTag, HtmlTreeBuilder tb) {
tb.insert(startTag);
tb.tokeniser.transition(TokeniserState.Rcdata);
tb.markInsertionMode();
tb.transition(Text);
}
private static void handleRawtext(Token.StartTag startTag, HtmlTreeBuilder tb) {
tb.insert(startTag);
tb.tokeniser.transition(TokeniserState.Rawtext);
tb.markInsertionMode();
tb.transition(Text);
}
}
| [
"justinwm@163.com"
] | justinwm@163.com |
457e60e63388d8b180c2adbba5d7973eea5e9438 | ceac24a76c5d32b95f90c915c2da7d7320202d53 | /app/src/main/java/com/example/moonquizz/QuestListActivity.java | efbce9324187751118c96e28ab6989d61c2bb8fe | [] | no_license | Araphlen/MoonQuizz | 4f8609e024522b43776f49952896d61a4c410107 | e1ff5599315060892e04fe96896002aa45ef9647 | refs/heads/master | 2023-05-26T10:17:38.670624 | 2021-06-13T09:44:15 | 2021-06-13T09:44:15 | 373,490,186 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,377 | java | package com.example.moonquizz;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.example.moonquizz.controler.controller;
import com.example.moonquizz.model.questions;
import java.util.ArrayList;
public class QuestListActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_quest_list);
init();
}
private controller controller;
private void init(){
//On récupère le controller
this.controller = controller.getInstance(this);
retour();
avatar();
String currentTheme= controller.getCurrentTheme();
int lvl= controller.getCurrentLvl();
TextView theme=findViewById(R.id.theme);
theme.setText(currentTheme);
TextView niveau=findViewById(R.id.lvl);
niveau.setText("Niveau "+lvl);
ArrayList<questions> listeQuest;
listeQuest = this.controller.recupListeQuest();
LinearLayout layout= findViewById(R.id.question);
Boolean valide=true;
for (int i=0; i<listeQuest.size(); i++){
//Création du bouton de choix de question
questions quest=listeQuest.get(i);
Button Butquestion= new Button(this);
Butquestion.setLayoutParams(new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT));
Butquestion.setText("Question n°"+quest.getNum());
int id = listeQuest.get(i).getId();
Butquestion.setTag(id);
//Couleur bleu naturelle
Butquestion.setTextColor(Color.parseColor("#ffffff"));
//Ajout de la séparation
TextView separation = new TextView(this);
separation.setLayoutParams(new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.WRAP_CONTENT));
layout.addView(Butquestion);
layout.addView(separation);
//Ajout de la fonction au bouton
//Si la question a été validé
if(valide){
Butquestion.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
//Selectionne de la question actuelle
controller.setCurrentQuest(quest);
if(quest.getNiveau()==1){
Intent intent = new Intent(QuestListActivity.this, TrueFalseActivity.class);
startActivity(intent);
} else {
Intent intent = new Intent(QuestListActivity.this, MCQActivity.class);
startActivity(intent);
}
}
});
//on met la couleur en vert
Butquestion.setBackgroundColor(Color.parseColor("#738b28"));
//Sinon, on laisse la question disponible et on bloque les questions suivantes
if(!controller.verifQuest(quest.getId(), controller.getCurrentUser().getId())){
valide=false;
Butquestion.setBackgroundColor(Color.parseColor("#0000FF"));
}
}else{
//Affichage d'un message d'erreur pour lors de la selection, et changement de couleur en rouge
Butquestion.setBackgroundColor(Color.parseColor("#8b0000"));
Butquestion.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Toast.makeText(QuestListActivity.this, "Il faut d'abord terminer les questions précédentes", Toast.LENGTH_LONG).show();
}
});
}
}
}
//Bouton retour a la liste des niveau
private void retour(){
findViewById(R.id.retour).setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(QuestListActivity.this, LevelActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
}
});
}
private void avatar() {
String name = controller.getCurrentUser().getAvatar();
int id = getResources().getIdentifier(name, "drawable", QuestListActivity.this.getPackageName());
Drawable drawable = getResources().getDrawable(id);
ImageButton button = findViewById(R.id.avatar);
button.setImageDrawable(drawable);
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(QuestListActivity.this, AvatarActivity.class);
String page = "quest";
intent.putExtra("PAGE", page);
startActivity(intent);
}
});
}
} | [
"Amraphel@netcourrier.com"
] | Amraphel@netcourrier.com |
862a41fa2a8bd7248aa4be73fab273c6be0cf4d6 | de4ae5fa634df1554c4aa630ee04872be37d92b6 | /Bank/src/BankAccountTester.java | 243fd8ef2d6b17f70aa599fc621dd08c50aab34f | [] | no_license | s1210045/CS175L-02 | 1f9831983471cb4ea7d656a61472ea186dfcff8e | 10209c74311d02e1ba765d3daf80ce4ee93c8346 | refs/heads/main | 2023-03-07T00:45:30.501920 | 2021-02-23T01:51:11 | 2021-02-23T01:51:11 | 332,934,488 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 826 | java | import java.util.Scanner;
public class BankAccountTester {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("Enter starting balance for this account: ");
int starbBal = 0;
Double startBal = in.nextDouble();
BankAccount myBankAccount = new BankAccount(startBal);
//Withdraw
System.out.println("The amount that will be withdrawn from the account : ");
double withdraw = in.nextDouble();
myBankAccount.deposit(withdraw);
//Deposit
System.out.println("Enter the amount that will be deposited to the account : ");
double deposit = in.nextDouble();
myBankAccount.withdraw(deposit);
//outcome
System.out.println("The balance of the account is: $" + myBankAccount.getBalance ());
}
}
| [
"ahaemah@gmail.com"
] | ahaemah@gmail.com |
24e5f5388d9afdd04d6fe7b635e2acef3b084af8 | e2be40b203fba640aee3d3266e0639f5211f2529 | /common/src/main/java/scheduling/model/Problem.java | 123e54120fe7cfaa989481db626b0974f275b59c | [] | no_license | erosb/scheduling | f600b24b071dc29f895a0314f85041f9d0e41c54 | 9c84aeb2831a7bacf2f3ba98a4c066398a29da3d | refs/heads/master | 2023-08-14T16:20:25.784638 | 2016-04-01T08:13:12 | 2016-04-01T08:13:12 | 36,844,033 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,679 | java | package scheduling.model;
import static java.util.Objects.requireNonNull;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static java.lang.String.format;
public class Problem {
public static Problem getDefault() {
Set<Employee> employees = allEmployees();
Map<WeekdayShift, ShiftRequirement> weekdayReqs = new HashMap<>(WeekdayShift.values().length);
weekdayReqs.put(WeekdayShift.MORNING, morningReq());
weekdayReqs.put(WeekdayShift.DAY, dayReq());
weekdayReqs.put(WeekdayShift.NIGHT, nightReq());
weekdayReqs.put(WeekdayShift.AFTERNOON, afternoonReq());
Map<WeekendShift, ShiftRequirement> weekendReqs = new HashMap<>(WeekendShift.values().length);
weekendReqs.put(WeekendShift.DAY, weekendReqs());
weekendReqs.put(WeekendShift.NIGHT , weekendReqs());
WeeklyRequirement weeklyReq = new WeeklyRequirement(weekdayReqs, weekendReqs);
return new Problem(employees, weeklyReq, 4);
}
public static Set<Employee> employees(int count, Skill... skills) {
Set<Skill> skillSet = new HashSet<>(Arrays.asList(skills));
String namePrefix = "Emp " + Arrays.stream(skills)
.map(Skill::toString)
.collect(Collectors.joining(" ")) + " ";
return IntStream.range(0, count)
.mapToObj(i -> namePrefix + i)
.map(name -> new Employee(name, skillSet))
.collect(Collectors.toSet());
}
private static Set<Employee> allEmployees() {
Set<Employee> rval = new HashSet<>(30);
rval.addAll(employees(3, Skill.LANG_EN, Skill.LANG_PL));
rval.addAll(employees(3, Skill.LANG_EN, Skill.LANG_ES));
rval.addAll(employees(7, Skill.LANG_EN, Skill.LANG_DE));
rval.addAll(employees(7, Skill.LANG_EN, Skill.LANG_FR));
rval.addAll(employees(7, Skill.LANG_EN, Skill.LANG_ITA));
return rval;
}
private static ShiftRequirement weekendReqs() {
ShiftRequirement req = new ShiftRequirement();
req.put(Skill.LANG_EN, 3);
req.put(Skill.LANG_DE, 1);
req.put(Skill.LANG_FR, 1);
req.put(Skill.LANG_ITA, 1);
return req;
}
private static ShiftRequirement afternoonReq() {
ShiftRequirement req = new ShiftRequirement();
req.put(Skill.LANG_EN, 3);
req.put(Skill.LANG_DE, 1);
req.put(Skill.LANG_FR, 1);
req.put(Skill.LANG_ITA, 1);
return req;
}
private static ShiftRequirement dayReq() {
ShiftRequirement req = new ShiftRequirement();
req.put(Skill.LANG_EN, 9);
req.put(Skill.LANG_DE, 3);
req.put(Skill.LANG_FR, 3);
req.put(Skill.LANG_ITA, 3);
req.put(Skill.LANG_PL, 1);
req.put(Skill.LANG_ES, 1);
return req;
}
private static ShiftRequirement nightReq() {
ShiftRequirement req = new ShiftRequirement();
req.put(Skill.LANG_EN, 4);
req.put(Skill.LANG_DE, 2);
req.put(Skill.LANG_FR, 1);
req.put(Skill.LANG_ITA, 1);
return req;
}
private static ShiftRequirement morningReq() {
ShiftRequirement morningReq = new ShiftRequirement();
morningReq.put(Skill.LANG_EN, 4);
return morningReq;
}
private final Set<Employee> employees;
private final WeeklyRequirement weekReq;
private final int weekCount;
public Problem(Set<Employee> employees, WeeklyRequirement weekReq, int weekCount) {
this.employees = requireNonNull(employees, "employees cannot be null");
this.weekReq = requireNonNull(weekReq, "weekReq cannot be null");
if (weekCount < 0) {
throw new IllegalArgumentException("weekCount must be non-negative");
}
this.weekCount = weekCount;
}
public Set<Employee> employees() {
return employees;
}
public WeeklyRequirement weekReq() {
return weekReq;
}
public int weekCount() {
return weekCount;
}
public Map<WeekdayShift, ShiftRequirement> weekdayReq() {
return weekReq.weekdayReq();
}
public Map<WeekendShift, ShiftRequirement> weekendReq() {
return weekReq.weekendReq();
}
public Employee employeeByName(String name) {
return employees.stream()
.filter(e -> e.name().equals(name))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException(format("employee [%s] not found", name)));
}
}
| [
"ebence88@gmail.com"
] | ebence88@gmail.com |
307a32c96bbe4849e27604f8b2d0e7eb5b586439 | 7ab3af5e6601aea4c491e2ab5a9ad5370e32e403 | /app/src/main/java/a1/example/com/myapplication/Adapter/HistoryInfoAdapter.java | e7c52ac1fe9419cd3c712d86b45c3f425adb5b1f | [] | no_license | nieaowei/simikongjian-andorid | 0e70213f5dad67474c6a1032deecf4a3c9dd0549 | 032db8a4d8e5a4dedb7c783e3fec20effb900b59 | refs/heads/master | 2022-11-10T00:25:30.938967 | 2020-06-10T14:58:33 | 2020-06-10T14:58:33 | 269,482,135 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,933 | java | package a1.example.com.myapplication.Adapter;
import android.content.Context;
import android.support.annotation.NonNull;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import java.util.List;
import a1.example.com.myapplication.Model.UserFriendModel;
import a1.example.com.myapplication.Model.UserInfoModel;
import a1.example.com.myapplication.R;
public class HistoryInfoAdapter extends ArrayAdapter<UserInfoModel> {
private int resourceId;
public HistoryInfoAdapter(Context context, int resource, List<UserInfoModel> objects) {
super(context, resource, objects);
resourceId = resource;
}
@NonNull
@Override
public View getView(int position, View convertView, ViewGroup parent) {
UserInfoModel userInfoModel = getItem(position);
View view;
HistoryInfoAdapter.ViewHolder viewHolder;
if(convertView == null) {
view = LayoutInflater.from(getContext()).inflate(resourceId,parent,false);
viewHolder = new HistoryInfoAdapter.ViewHolder();
viewHolder.name = (TextView)view.findViewById(R.id.history_time);
viewHolder.name2 = (TextView)view.findViewById(R.id.history_content);
view.setTag(viewHolder);//将viewHolder存储在view中
}else{
view = convertView;
viewHolder = (HistoryInfoAdapter.ViewHolder)view.getTag(); //重新获取viewHolder
}
// viewHolder.name.setText(book.getFriendname());
viewHolder.name.setText(userInfoModel.getUpdatedt());
viewHolder.name2.setText("体重："+userInfoModel.getUserweight()+"kg 身高："+userInfoModel.getUserheight()+"cm 爱好："+userInfoModel.getUserfavorite());
return view;
}
class ViewHolder{
TextView name;
TextView name2;
}
}
| [
"nieaowei@gmail.com"
] | nieaowei@gmail.com |
bbd3d37f084566695e0911458078db854ab061ce | af2d521d8689e2dcd551f24f62c8342e641ee324 | /app/src/main/java/com/achyut/backgrounderaser/Drawing_View/brushes/androidpathbrushes/PathBrush.java | ea27ca69abe19b1718e6df4cf5e8d4c44d121c4b | [] | no_license | AchyutInfotech921/BackgroundEraser | 469596fdfb0a225f6bc843b847609c7490a4a43a | 2179323a2029680a3bff875bd98bd3eae8a5325a | refs/heads/master | 2023-03-05T17:35:44.505120 | 2021-02-13T10:52:33 | 2021-02-13T10:52:33 | 338,549,353 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 742 | java | package com.achyut.backgrounderaser.Drawing_View.brushes.androidpathbrushes;
import android.graphics.Paint;
import com.achyut.backgrounderaser.Drawing_View.brushes.Brush;
public abstract class PathBrush extends Brush {
PathBrush(int minSizePx, int maxSizePx) {
super(minSizePx, maxSizePx);
mPaint.setStyle(Paint.Style.STROKE);
mPaint.setStrokeJoin(Paint.Join.ROUND);
mPaint.setStrokeCap(Paint.Cap.ROUND);
}
@Override
public void setSizeInPercentage(float sizePercentage) {
super.setSizeInPercentage(sizePercentage);
mPaint.setStrokeWidth(getSizeInPixel());
}
@Override
public int getSizeForSafeCrop() {
return super.getSizeForSafeCrop() * 2;
}
}
| [
"Mypwd@123"
] | Mypwd@123 |
bbfabfd4a22f8575b6896940f6dbd24173415fe3 | 9b18f7f0cf905eb9dcde3a4b38cf372e43053a47 | /src/main/java/com/earnest/homework/selenium/pages/checkout/CheckoutPage.java | 083f93496e120b1cdf215f4890abdfd2bcaa8f6b | [] | no_license | SuyogLokhande/earnest_suyog_homework | a554c480d584770f2562390ccb8d2f58ba0c1632 | b9a488da93cefc22572affd298e7246a487ce497 | refs/heads/master | 2021-01-20T18:52:21.580271 | 2016-12-24T17:07:14 | 2016-12-24T17:07:14 | 64,606,803 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,639 | java | //
// Suyog Lokhande
// Copyright
// Confidential and Proprietary
// ALL RIGHTS RESERVED
// 405 - 200 - 7802
// Jul 30, 2016
package com.earnest.homework.selenium.pages.checkout;
import java.util.ArrayList;
import org.apache.log4j.Logger;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import com.earnest.homework.selenium.utils.TestUtils;
import com.earnest.homework.selenium.pages.common.Page;
public class CheckoutPage extends Page{
private static final Logger logger = Logger.getLogger(CheckoutPage.class);
//Better to use CSS value than xpath. So if developer moved from one panel to other it will not break this script.
//Finding all required elements required for CheckoutPage.
@FindBy(css="[id='subtotal']")
private WebElement subtotalField;
@FindBy(css="[id='taxes']")
private WebElement taxesField;
@FindBy(css="[id='total']")
private WebElement totalField;
public CheckoutPage(WebDriver driver) {
super(driver);
}
public ArrayList<String> confirmOrder(WebDriver driver){
ArrayList<String> confirmOrderFromGUI = new ArrayList<String>();
try{
logger.info("Grabbing SubTotal value from confirmation page.");
TestUtils.highlightElement(driver, subtotalField);
String subTotalFromGUI = TestUtils.getText(driver, subtotalField);
logger.debug("Adding SubTotal to ArrayList.");
confirmOrderFromGUI.add(0,subTotalFromGUI);
} catch (NoSuchElementException e) {
logger.error("subtotalField Element cannot be found.");
}
try{
logger.info("Grabbing Tax value from confirmation page.");
TestUtils.highlightElement(driver, taxesField);
String taxesFromGUI = TestUtils.getText(driver, taxesField);
logger.debug("Adding Tax to ArrayList.");
confirmOrderFromGUI.add(1, taxesFromGUI);
} catch (NoSuchElementException e) {
logger.error("taxField Element cannot be found.");
}
try{
logger.info("Grabbing Total value from confirmation page.");
TestUtils.highlightElement(driver, totalField);
String totalFromGUI = TestUtils.getText(driver, totalField);
logger.debug("Adding Total to ArrayList.");
confirmOrderFromGUI.add(2, totalFromGUI);
} catch (NoSuchElementException e) {
logger.error("totalField Element cannot be found.");
}
return confirmOrderFromGUI;
}
}
| [
"suyog.lokhande@gmail.com"
] | suyog.lokhande@gmail.com |
7be51151cb22baea43e7707be94ad1b59c52eb94 | f7c09cfcbe351693759c8a6eccdecca05514d089 | /src/com/tsekhanovich/patterns/behavioral/mediator/example1/ConcreteColleague2.java | ede149bdb79f97665301e99cefaae119bb19a4a4 | [] | no_license | PavelTsekhanovich/SimplePatterns | 4453ac51c0be4c3f322cb4b917da2571ceb0ceba | 475fbf5cc40b36724006f7dc404afabfa064d646 | refs/heads/master | 2020-03-26T22:30:19.564244 | 2018-10-23T19:49:56 | 2018-10-23T19:49:56 | 145,463,949 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 331 | java | package com.tsekhanovich.patterns.behavioral.mediator.example1;
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void notify(String message) {
System.out.println("Colleague2 gets message: " + message);
}
}
| [
"p.tsekhanovich93@gmail.com"
] | p.tsekhanovich93@gmail.com |
f7a1290f7b9e12696b474a11613a5e4736bd6f42 | a12988a474e4d11f8befd22eda71622b55fce3ef | /src/fr/kb/polymorphisme/Terrain.java | 4df0df46601586cace5ef9551339a883aadb4767 | [] | no_license | kobanogit/Java-polymorphism-Cards-Game | ac26c3f02571f6344e266ba440eb1df22d87527e | 6fb8adc71f15b57667a1d19ddb5bb900e453c6d3 | refs/heads/master | 2020-03-29T15:59:24.489456 | 2018-09-24T11:18:41 | 2018-09-24T11:18:41 | 150,091,238 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 715 | java | package fr.kb.polymorphisme;
public class Terrain implements Carte {
Couleur couleur = Couleur.blanc;
int cout = 0;
public Terrain (char couleur) {
switch (couleur) {
case 'B':
this.couleur = Couleur.blanc;
break;
case 'b':
this.couleur = Couleur.bleu;
break;
case 'n':
this.couleur = Couleur.noir;
break;
case 'r':
this.couleur = Couleur.rouge;
break;
case 'v':
this.couleur = Couleur.vert;
break;
}
// System.out.println("Carte Terrain couleur " + couleur);
System.out.println("Un nouveau terrain.");
}
@Override
public String afficher() {
return "Un terrain " + couleur;
}
}
| [
"mlme@disroot.org"
] | mlme@disroot.org |
64e53a1a3227318fd619417d54f8ab2fc1210c10 | 152754c2981cbcfdb1fcce6068efdd937c2922aa | /04.mid/05.overload/src/mid/overload/method/Calculator.java | 17e0ca1e45eb2432730860860b61e60821b36023 | [] | no_license | fs5013-furi-sutao/java-bootcamp-answers | 3c77abba19879b854b39b2fbdba8ce79c8ff90bf | 4c0034374a3119397f8a5d82c28d00b47d8fd7fa | refs/heads/main | 2023-08-07T03:00:14.307895 | 2021-10-04T13:31:43 | 2021-10-04T13:31:43 | 320,149,273 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 331 | java | package mid.overload.method;
public class Calculator {
public static void main(String[] args) {
int a = 1;
int b = 2;
int[] array = {
1, 5, 9, 2, 55,
};
Adder adder = new Adder();
adder.showResultAdded(a, b);
adder.showResultAdded(array);
}
}
| [
"fs5013.furi.sutao@gmail.com"
] | fs5013.furi.sutao@gmail.com |
2b25c19fec2efad00758bccc9116b648057b6dfc | 42ecc75739b291474d04a5937304ca6db76a5ea8 | /Test_02/Chapter_Test_008.java | 09696945feac960e8d096fe9c4eec50bbb950bbc | [] | no_license | Luther0812/JAVA_Study | 6c4c8f30fd752eb9b8473e97d7e91b36af8b5680 | 63236589a2f8f93e03f8ce0f707971ff4753d8c6 | refs/heads/master | 2021-01-12T01:37:16.827625 | 2018-08-09T11:23:49 | 2018-08-09T11:23:49 | 78,411,786 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 426 | java | /**Language:Java Standard Edition
* Author:Luther
*/
package Test_02;
/**
*
*
*/
import java.util.Scanner;
public class Chapter_Test_008 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("Enter an ASCII code : ");
int code = input.nextInt();
char value = (char)code;
System.out.println("The character for ASCII code " + code + " is " + value);
}
}
| [
"luther0812@163.com"
] | luther0812@163.com |
8267d50684d8471b136a790a304c58838d6d5329 | 4c74007bbbf2038f8fa85e1f2a5cb3dc7444fe79 | /1-escala-app-master_Redis/src/main/java/ar/edu/undav/escalaapp/config/RedisConfig.java | 9ff95652cdf2c6163421445a199f29c261cebcdc | [] | no_license | FedericoCalonge/TP2-Docker-Redis-NGINIX | df37cacc26e76413ec80229946eb4c3286d89d67 | 7942384ed437986c60a19fdc971d36b775d3e066 | refs/heads/master | 2023-03-10T15:09:45.202727 | 2021-03-04T06:52:13 | 2021-03-04T06:52:13 | 218,200,171 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 918 | java | package ar.edu.undav.escalaapp.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
@Configuration
@EnableRedisRepositories
public class RedisConfig {
@Bean
RedisTemplate redisTemplate(){
RedisTemplate redisTemplate=new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory());
return redisTemplate;
}
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
return new LettuceConnectionFactory(new RedisStandaloneConfiguration("redis", 6379));
}
}
| [
"calongefederico@gmail.com"
] | calongefederico@gmail.com |
e4fcff2891ed7f356a3ea68ff9fd2366ef390d2e | 62ba8ff4ceaeb61cc30383db1e2e05ec1f487c30 | /proj2/workspace/src/medicalstuff/client/gui/medicalstuff/menu/ServerInfo.java | 196ad26af55bd451ce69bc3f0d3a975b9c77952f | [] | no_license | ada10lgu/EIT060 | 04ce6981f65f885eab916a4c5aa6a8cd0051cb58 | 5683142faf19e12180819263a7f4c83909503400 | refs/heads/master | 2021-01-10T14:50:12.684991 | 2016-03-03T21:09:23 | 2016-03-03T21:09:23 | 50,655,562 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,026 | java | package medicalstuff.client.gui.medicalstuff.menu;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import medicalstuff.client.model.ClientModel;
@SuppressWarnings("serial")
public class ServerInfo extends JMenuItem implements ActionListener{
private ClientModel model;
public ServerInfo(ClientModel model) {
super("Server Information");
addActionListener(this);
this.model = model;
}
@Override
public void actionPerformed(ActionEvent e) {
HashMap<String,String> data = model.getServerInfo();
StringBuilder sb = new StringBuilder();
sb.append("Server information\n");
sb.append("Serial: ").append(data.get("serial")).append("\n");
sb.append("Subject: ").append(data.get("subject")).append("\n");
sb.append("Issuer: ").append(data.get("issuer")).append("\n");
JOptionPane.showMessageDialog(null, sb.toString(),"Server Information",JOptionPane.INFORMATION_MESSAGE);
}
}
| [
"lars.gustafson@gmail.com"
] | lars.gustafson@gmail.com |
589b9dfe9ec0a8e268cafbe4e799410053c6a13b | 39558b6932235c77bee3fd72b943d0b77de29d96 | /src/main/java/com/duinn/brewbros/config/ApplicationProperties.java | d7fa102e822de3e2eb9e8f5b02ebe1eeffff6514 | [] | no_license | duinn/brew-bros | eac1b65900e668f2c0124b18742b339e38984d1a | 6dbfbd18048a6a78b17b2140d494714c84a8b0bc | refs/heads/master | 2022-12-22T15:03:09.012230 | 2019-11-13T17:52:52 | 2019-11-13T17:52:52 | 185,176,982 | 1 | 1 | null | 2022-12-16T04:59:32 | 2019-05-06T10:43:32 | Java | UTF-8 | Java | false | false | 428 | java | package com.duinn.brewbros.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Properties specific to Brewbros.
* <p>
* Properties are configured in the {@code application.yml} file.
* See {@link io.github.jhipster.config.JHipsterProperties} for a good example.
*/
@ConfigurationProperties(prefix = "application", ignoreUnknownFields = false)
public class ApplicationProperties {
}
| [
"dunnep6@tcd.ie"
] | dunnep6@tcd.ie |
17f9ad97e4bc3e19876c5652b6cf60fbe005d504 | 5ce373b4886bece2b3bc102fb11ae685904c61f3 | /DesktopJEE/src/main/java/tn/mario/moovtn/remotes/TripManagerLocal.java | 7a6b1869eaf75fd39af89b7eb808612f18698cff | [] | no_license | AmineKolsi/mariosecretdesk | 83820ff242306f6374d5cb454216c67bd36dfe49 | 23bc5706f6b5d0fc25caf6f5c480e40604fd08b8 | refs/heads/master | 2021-01-13T00:51:55.911629 | 2015-10-14T18:37:39 | 2015-10-14T18:37:39 | 43,830,675 | 0 | 5 | null | 2015-10-14T18:37:40 | 2015-10-07T16:53:06 | Java | UTF-8 | Java | false | false | 383 | java | package tn.mario.moovtn.remotes;
import java.util.List;
import javax.ejb.Local;
import tn.mario.moovtn.entities.Notification;
import tn.mario.moovtn.entities.Trip;
@Local
public interface TripManagerLocal {
public void add(Trip u);
public Trip findById(Integer id);
public List<Trip>getAllTrips();
public void update(Trip u);
public void delete(Trip u);
}
| [
"amine.bouharb@esprit.tn"
] | amine.bouharb@esprit.tn |
af6411cccad9071cd893ee9185e06d29a07dd44f | 54c76a82e2cd15a64446b8202b8b739904cf6185 | /src/test/java/com/cmcc/ms/service/datashow/impl/OverallAnalysisServiceImplTest.java | 37935b9b5436c93278a19da7237f3c282ea3c6db | [] | no_license | 0xsb/demoscdbn | 6deeb5d2d56f72c5f3b0a13ec5a4105cf7d5167c | e5c21b30df6b683d0489b429e97e49692a52c016 | refs/heads/master | 2020-03-27T17:37:39.046490 | 2017-10-30T07:06:22 | 2017-10-30T07:06:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,994 | java | package com.cmcc.ms.service.datashow.impl;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import com.cmcc.ms.entity.datashow.OverallAnalysis;
import com.cmcc.ms.mapper.OverallAnalysisMapper;
import com.cmcc.ms.service.BaseTestCase;
/**
*
* @author chenyouchao-yl
*/
public class OverallAnalysisServiceImplTest extends BaseTestCase {
/** The overall analysis mapper. */
@Autowired
private OverallAnalysisMapper overallAnalysisMapper;
@Autowired
private OverallAnalysisServiceImpl overallAnalysisServiceImpl;
/**
* Run the void insertOverAnalysisList(List<OverallAnalysis>) method test.
*
* @throws Exception
*
*/
@Test
@Rollback
public void insertOverAnalysisListTest() throws Exception {
OverallAnalysis asl = new OverallAnalysis();
asl.setName("省际直连");
OverallAnalysis aml = new OverallAnalysis();
aml.setName("免费对等直连");
OverallAnalysis afl = new OverallAnalysis();
afl.setName("付费穿透");
OverallAnalysis agk = new OverallAnalysis();
agk.setName("国际公司客户");
OverallAnalysis afz = new OverallAnalysis();
afz.setName("付费对等直连");
List<OverallAnalysis> list = new ArrayList<OverallAnalysis>();
list.add(asl);
list.add(aml);
list.add(agk);
list.add(afz);
list.add(afl);
overallAnalysisServiceImpl.insertOverAnalysisList(list);
}
/**
* Run the void selectOAList() method test.
*
* @throws Exception
*
*/
@Test
@Rollback
public void selectOAListTest() throws Exception {
overallAnalysisServiceImpl.selectOAList();
overallAnalysisServiceImpl.selectOAList();
}
}
| [
"cjj0966141103@126.com"
] | cjj0966141103@126.com |
4ea4187235df7a959680a414424fcd34cb8314a2 | ab5c3303e6c360b1af5151e0bd871472d55e9434 | /Final/Final/src/Rental.java | 60f0d46d393e0a1de2e02ea00cca77007c01170b | [] | no_license | espinozahector/EspinozaHectorCSC18A | 45f745024187a766972e144a89f595b775719913 | 35c9608bc090660bbae5a226a062dc6d0ddcaa5a | refs/heads/master | 2021-05-04T11:46:32.099075 | 2017-12-10T08:23:43 | 2017-12-10T08:23:43 | 51,953,226 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,910 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author rcc
*/
public abstract class Rental {
private boolean newModel;
private double rentalCost;
private long rentalNumber;
Rental()
{
newModel = false;
rentalCost = 0;
rentalNumber = 0;
}
public Rental(boolean newnewModel, double newrentalCost, long newrentalNumber)
{
setnewModel(newnewModel);
setrentalCost(newrentalCost);
setrentalNumber(newrentalNumber);
}
public boolean equals(Rental f1)
{
return this.rentalNumber == f1.rentalNumber;
}
//New Model
public boolean getnewModel()
{
return newModel;
}
public void setnewModel(boolean newnewModel)
{
newModel = newnewModel;
}
//Rental Cost
public double getrentalCost()
{
return rentalCost;
}
public void setrentalCost(double newrentalCost)
{
if ( newrentalCost==0 ) throw new IllegalArgumentException();
if(newrentalCost < 0) {
rentalCost= (-newrentalCost);
}
else {
rentalCost = newrentalCost;
}
}
//Rental Number
public long getrentalNumber()
{
return rentalNumber;
}
public void setrentalNumber(long newrentalNumber)
{
if(newrentalNumber == 0) throw new IllegalArgumentException();
if(newrentalNumber < 0){
rentalNumber = (-newrentalNumber);
}
else {
rentalNumber = newrentalNumber;
}
}
//To String
public String toString()
{
return "newModel: "+getnewModel()+"\nrentalCost: "+
rentalCost+"\nrentalNumber: "+rentalNumber;
}
public abstract double lateCharge();
}
| [
"espinozahector68@gmail.com"
] | espinozahector68@gmail.com |
7b4983d4d3bee8cf8520627aeeae69498840292f | d9e449ae2a99eb54bd5fa27f188506e76119de0b | /core/src/main/java/com/meslewis/simplegltf2/data/GLTFTexture.java | 6c05b7e633e640b4e3310adfb4299be10ef1fa77 | [
"MIT"
] | permissive | junglelan/SimpleGLTF2 | f4b0f90fa8045019bd70be3d1065edfe45cb4da3 | a668058c2cb82cefefc7005dd5796cea1ea52668 | refs/heads/master | 2022-04-04T23:31:11.788913 | 2020-02-08T18:39:43 | 2020-02-08T18:39:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,374 | java | /*
* Copyright (c) 2020. Morgan Lewis <https://github.com/MESLewis>
* This file is part of the SimpleGLTF2 project which is released under the MIT License.
* See <https://github.com/MESLewis/SimpleGLTF2/blob/master/LICENSE> for more information
*/
package com.meslewis.simplegltf2.data;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* A texture and its sampler.
*/
public class GLTFTexture extends GLTFChildOfRootProperty {
private static final GLTFSampler defaultSampler = new GLTFSampler();
/**
* The index of the sampler used by this texture. When undefined, a sampler with repeat wrapping
* and auto filtering should be used.
*/
private GLTFSampler sampler = defaultSampler;
/**
* The index of the image used by this texture. When undefined, it is expected that an extension
* or other mechanism will supply an alternate texture source, otherwise behavior is undefined.
*/
private GLTFImage sourceImage;
public GLTFImage getSourceImage() {
return sourceImage;
}
@JsonProperty("source")
private void setSourceImage(int index) {
gltf.indexResolvers.add(() -> sourceImage = gltf.getImage(index));
}
public GLTFSampler getSampler() {
return sampler;
}
@JsonProperty("sampler")
private void setSampler(int index) {
gltf.indexResolvers.add(() -> sampler = gltf.getSampler(index));
}
}
| [
"MESLewis@gmail.com"
] | MESLewis@gmail.com |
c03ad7b4ebe2aed0ce17de25e1a508064f7e6db9 | 63debf1215b760b5d94a176fd505dc89e9c17e8c | /module_orc/src/main/java/com/example/module_orc/ignore/NeigeIgnoreRect.java | fa864097a78506158cadb982d06bd86cfcbfd854 | [] | no_license | listenbehind/OpencvDemo | 19a2a053e0d1e794d134d7bd5102576c6155f066 | 1a86b9e02284444aedb4ce1f04c45ea93541551a | refs/heads/master | 2023-03-16T02:01:05.534078 | 2020-01-16T09:04:52 | 2020-01-16T09:04:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 477 | java | package com.example.module_orc.ignore;
import com.example.module_orc.OrcModel;
import org.opencv.core.Rect;
import java.util.ArrayList;
import java.util.List;
/**
* 作者：士元
* 时间：2019/9/16 18:07
* 邮箱：wuzuqing@linghit.com
* 说明：内阁
*/
public class NeigeIgnoreRect implements IIgnoreRect {
@Override
public List<OrcModel> ignoreRect(List<Rect> rects) {
List<OrcModel> result = new ArrayList<>();
return result;
}
}
| [
"wuzuqing@linghit.com"
] | wuzuqing@linghit.com |
b059870307191558a5382c093559d58fec9c7097 | 3c2572b9766c3df7b89a0a8d7c632d85768c58f9 | /Coding-Expert/src/com/amazon/interview/Arraywith0and1.java | 88fe4c28a97065ecae8dc90f2deba1a7a367df67 | [] | no_license | nanocent/FirstProject | 131d8857f508196c9a41deb1c8a116d7aeaa96c5 | b5c86f4cc66a789931d6d0ef0f821d9c8031d5d9 | refs/heads/master | 2020-12-06T21:59:45.329394 | 2019-10-19T12:45:26 | 2019-10-19T12:45:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 639 | java | package com.amazon.interview;
public class Arraywith0and1 {
public static void main(String[] args) {
int[] arr = { 0, 1, 0, 1, 1, 1, 0, 0, 1 };
int x = 0, y = 0, x1 = 0, y1 = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 0)
x++;
else
y++;
}
int[] zeros = new int[x];
int[] ones = new int[y];
for (int i : arr) {
if (i == 0) {
zeros[x1] = i;
x1++;
} else if (i == 1) {
ones[y1] = i;
y1++;
}
}
for (int i : ones) {
System.out.print(i);
}
System.out.println("zeros");
for (int j : zeros)
System.out.print(j);
}
}
| [
"ankush@Ankush-PC"
] | ankush@Ankush-PC |
ead7b4592482fe8c8a06fff5b32393488a4a393b | 1b72958ab7d8749594fd0dca20e3d9e793151b4e | /application-contentbridge/content/oastools/java/com/ctb/commands/CIMCommand.java | a16eef1deb1f37a2ce2a50bef0abafc957e89610 | [] | no_license | sumit-sardar/GitMigrationRepo01 | d0a89e33d3c7d873fac2dd66a7a5e59fd2b1bc3a | a474889914ea0e9805547ac7f4659c49e1a6b712 | refs/heads/master | 2021-01-17T00:45:16.256869 | 2016-05-12T18:37:01 | 2016-05-12T18:37:01 | 61,346,131 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,447 | java | package com.ctb.commands;
public interface CIMCommand {
//This is where command strings are defined for the command line interface
public static final String BUILD_ASSESSMENT = "buildassessment";
public static final String BUILD_TEST = "buildtest";
public static final String MAP_ITEMS = "mapitems";
public static final String MAP_ITEMS_VALIDATE = "mapitemsvalidate";
public static final String IMPORT_ITEMS = "importitems";
public static final String IMPORT_ITEMS_VALIDATE = "importitemsvalidate";
public static final String IMPORT_AND_MAP_ITEMS = "importandmapitems";
public static final String CREATE_PDF_THROUGH_FILE = "generatepdf";
public static final String GENERATE_MEDIA_FOR_EDITOR_REVIEW = "generatemediaforeditorreview";
public static final String GENERATE_PDF = "generatepdf";
public static final String VALIDATE_ITEM_XML = "validateitemxml";
public static final String MAPPING_HIERARCHY = "mappinghierarchy";
public static final String FLATTENED_MAPPING_HIERARCHY = "flattenedmappinghierarchy";
public static final String PRODUCT_REPORT = "productreport";
//used only for testing
public static final String IMPORT_ITEMS_NO_MEDIA = "importnomedia";
public static final String ROUNDTRIP_MAP = "roundtrip_map";
public static final String ROUNDTRIP_VALIDATE = "roundtrip_validate";
public static final String TESTMAP_INITIAL = "testmap_initial";
public static final String TESTMAP_COMPARE = "testmap_compare";
public static final String TESTMAP_MERGE = "testmap_merge";
public static final String TESTMAP_MERGE_VALIDATE = "testmap_merge_validate";
public static final String TESTMAP_OBJECTIVE = "testmap_objective_update";
public static final String TESTMAP_ANSWERKEY = "testmap_answerkey";
public static final CommandInfo[] activeCommands =
{
new CommandInfo(
BUILD_ASSESSMENT,
"Imports an Assessment file into an OAS instance"),
new CommandInfo(
BUILD_TEST,
"Imports a SubTest file into an OAS instance"),
new CommandInfo(
MAP_ITEMS,
"Maps an Item/ItemSet file into an OAS instance"),
new CommandInfo(
MAP_ITEMS_VALIDATE,
"Validates an Item/ItemSet file for mapping"),
new CommandInfo(IMPORT_ITEMS, "Imports an Item/ItemSet file"),
new CommandInfo(
IMPORT_ITEMS_VALIDATE,
"Validates an Item/ItemSet file for import"),
new CommandInfo(
MAPPING_HIERARCHY,
"Generates a projected mapping report"),
new CommandInfo(
FLATTENED_MAPPING_HIERARCHY,
"Generates a flattened projected mapping report"),
new CommandInfo(PRODUCT_REPORT, "Generates a Product Report"),
new CommandInfo(
ROUNDTRIP_MAP,
"Maps all CAB items in a source OAS instance to specified frameworks in a target OAS instance"),
new CommandInfo(
ROUNDTRIP_VALIDATE,
"Validates mapping of all CAB items in a source OAS instance to specified frameworks in a target OAS instance"),
new CommandInfo(
IMPORT_AND_MAP_ITEMS,
"Imports and maps an Item/ItemSet file to all frameworks in an OAS instance"),
new CommandInfo(
TESTMAP_INITIAL,
"Builds initial test map from list of item Ids"),
new CommandInfo(
TESTMAP_COMPARE,
"Compares the contents of two cvs files"),
new CommandInfo(
TESTMAP_MERGE,
"Merges mapping in the csv file into mapping file"),
new CommandInfo(
TESTMAP_MERGE_VALIDATE,
"Validates mapping in csv against the current mapping file"),
new CommandInfo(
TESTMAP_OBJECTIVE,
"Updates the objective description in a csv file"),
new CommandInfo(
TESTMAP_ANSWERKEY,
"Updates the csv file with the answer key from test XML"),
new CommandInfo(
CREATE_PDF_THROUGH_FILE,
"Create PDF content to a file"),
new CommandInfo(
GENERATE_MEDIA_FOR_EDITOR_REVIEW,
"Generate PDF and Flash media for a given XML file"),
new CommandInfo(
GENERATE_PDF,
"Generate PDF media for a given XML file"
),
new CommandInfo(
VALIDATE_ITEM_XML,
"Validate item XML"
)
//new CommandInfo(IMPORT_ITEMS_NO_MEDIA,), //only used for testing - not available on cmdLine
};
/**
* The command name for a concrete class is defined as a static final String
* in the interface com.ctb.commands.CIMCommand. Concrete CIMCommands
* return their corresponding Strings.
*/
String getCommandName();
}
class CommandInfo {
final String name;
final String description;
CommandInfo(String commandName, String description) {
this.name = commandName;
this.description = description;
}
}
| [
""
] | |
9f2b3ff144e519d2d4a8af6c785ce253de2077ec | 8e32a0f37454ca823374e2091daa519a77caf407 | /src/test/java/api/TrainingResourceFunctionalTesting.java | 5c5014a5870a2c3eaa6564c59763534aba1328e7 | [] | no_license | xisjing/JEE.Paddle | e6c346b6b5ad5d7780c87cc6bb9c2a25036a6824 | 38eb325902fa31d6e39ae6dbdf40a04fce1f2caa | refs/heads/master | 2021-01-10T01:21:15.382956 | 2016-04-01T11:43:13 | 2016-04-01T11:43:13 | 53,337,657 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,301 | java | package api;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import org.junit.After;
import org.junit.Test;
import business.api.Uris;
import business.wrapper.AvailableTime;
import data.entities.Training;
public class TrainingResourceFunctionalTesting {
RestService restService = new RestService();
@Test
public void testcreateTraining() {
restService.createCourt("1");
restService.createCourt("2");
Calendar day = Calendar.getInstance();
day.add(Calendar.DAY_OF_YEAR, 1);
day.set(Calendar.HOUR_OF_DAY,12);
new RestBuilder<String>(RestService.URL).path(Uris.TRAINING).body(new AvailableTime(1, day)).post().build();
day.set(Calendar.HOUR_OF_DAY,14);
new RestBuilder<String>(RestService.URL).path(Uris.TRAINING).body(new AvailableTime(2, day)).post().build();
}
@Test
public void testshowTrainings() {
String token = restService.loginAdmin();
List<Training> list = Arrays.asList(new RestBuilder<Training[]>(RestService.URL).path(Uris.TRAINING).basicAuth(token, "")
.clazz(Training[].class).get().build());
}
@After
public void deleteAll() {
new RestService().deleteAll();
}
}
| [
"xisijing@gmail.com"
] | xisijing@gmail.com |
4baa941661790cb3f95d00713d69e720323dcf96 | 02c079c70b36f01e95d4f137ebe3ab8e003f4f6e | /maven_code/maven_javasql/src/main/java/yang/muyun/domain/Items.java | 77741fbc0be41c44f218f3d908b03270a2ecc2d8 | [] | no_license | YL-python/yl_java_code | b2f0436c3edfe9dafa8c6f079bf7ad6515977c3a | 938cfef510dff1ab37836fd962e2944291c7b3ac | refs/heads/master | 2022-12-23T12:14:48.914352 | 2020-02-10T06:56:39 | 2020-02-10T06:56:39 | 219,674,470 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 550 | java | package yang.muyun.domain;
public class Items {
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "item{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
| [
"2336739721@qq.com"
] | 2336739721@qq.com |
ec1fd784ead093889a06d6fa0ba873fb1fb5f31e | 2e007171683616881b62eb3f1db8b271dc3284d1 | /app/src/main/java/com/zhihuianxin/xyaxf/app/payment/CashierDeskFeeNormalAdapter.java | cf4638d3d38d9580aa46e1ac9e2a0d5e99111901 | [
"Apache-2.0"
] | permissive | ZcrPro/axinfu | cc85856cefbd4b2050566d2d18f611e664facd9d | 66fc7c6df4c6ea8a8a01a0008d5165eb6e53f09a | refs/heads/master | 2020-03-20T08:45:38.205203 | 2018-07-09T01:56:39 | 2018-07-09T01:56:39 | 127,858,246 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 927 | java | package com.zhihuianxin.xyaxf.app.payment;
import android.content.Context;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.pacific.adapter.RecyclerAdapter;
import com.pacific.adapter.RecyclerAdapterHelper;
import com.zhihuianxin.xyaxf.R;
import java.util.List;
public class CashierDeskFeeNormalAdapter extends RecyclerAdapter<FeeListData> {
public CashierDeskFeeNormalAdapter(Context context, @NonNull int... layoutResIds) {
super(context, layoutResIds);
}
public CashierDeskFeeNormalAdapter(Context context, @Nullable List<FeeListData> data, @NonNull int... layoutResIds) {
super(context, data, layoutResIds);
}
@Override
protected void convert(RecyclerAdapterHelper helper, FeeListData feeList) {
helper.setText(R.id.tv_sub_fee_name, feeList.name);
helper.setText(R.id.tv_sub_fee_amount, feeList.amount);
}
} | [
"zcrpro@gmail.com"
] | zcrpro@gmail.com |
3842c3cdb96e9e4cccab00e39e9d870f63220b12 | 5c30c7ea2a2dbc9c17f44814b3eba5847a7b26ae | /02_java_array_basic/src/step2_01/array/arrayEx01.java | 48115505f44c0ba3a7fbb5bb1a72521be148f4c9 | [] | no_license | th940509/02_java_array_basic | 8b04b703215e9662780cfd0b2a63633de376941a | fa5275a882a15ee2fe96d390fa6988859883d8ee | refs/heads/master | 2023-05-13T11:49:29.434190 | 2021-06-03T05:53:04 | 2021-06-03T05:53:04 | 352,563,918 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,102 | java | package step2_01.array;
import java.lang.reflect.Array;
import java.util.Arrays;
public class arrayEx01 {
/*
*
* int [] abc = null;
* abc = new int [5]
*
* # 배열 ( array )
*
* [ 형식 ]
*
* 1) 자료형[] 배열명 = new 자료형[방의개수];
* 2) 자료형 배열명[] = new 자료형[방의개수];
*
* - '같은 자료형'의 데이터를 '여러개' 저장하기 위한 자료구조
* - 인덱스 (index) : 0부터 시작하는 방 번호가 부여된다.
* - 배열은 주소변수이다.
* - 배열을 크기가 변하지 않는다. 배열을 삭제하여도 배열의 크기는 고정되어있다.
* - 배열의 요소를 지우는 것은 배열의 초깃값으로 다시 저장하는 것을 의미한다.
*
* */
public static void main(String[] args) {
// 참고) 일반변수
int nVar = 0;
nVar = 3;
System.out.println(nVar); // 변수의 값이 출력된다.
int[] arr = null;
arr = new int [5];
System.out.println(arr); // 배열의 주소가 출력된다.
//배열은 변수와 다르게 배열 생성시에 초기값이 세팅이 되어 있다.
System.out.println(arr[0]); // 정수 형태의 배열은 0으로 초기화 되고
System.out.println(arr[1]); // 다른 자료형은 직접 확인해보자.
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
//java.lang.ArrayIndexOutOfBoundsException: 99
//배열의 범위가 넘어설 때 발생하는 에러메세지 ( 메세지가 나오는 이유와 해결법 암기)
//System.out.println(arr[99]);
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
System.out.println();
for (int i = 0; i < arr.length; i ++) { // arr.length : 배열의 크기를 자바 계산하여 표현
System.out.println(arr[i]);
}
System.out.println();
System.out.println(Arrays.toString(arr)); // (참고) 배열이 익숙해진 후부터 사용
arr = null; //배열전체 삭제
}
}
| [
"user@401-10"
] | user@401-10 |
38f2a061acb61c5bb42cb3f2d854ab9a844f637d | 75b2bbfbb0b516595ec455811894b793e8f57e60 | /app/src/main/java/com/compta/firstak/notedefrais/Gestion_Salarie/Get_Salarier.java | 6933609d7ea8121c7a93c3c8b8cb864b5528c061 | [] | no_license | ghadhab/NoteDeFrais | 3e5eb06dcf8504d0fc9b858954925a5df0f07f57 | cf32dacda235850747dc852ae256cd0cbdd45bb6 | refs/heads/master | 2021-01-20T01:17:18.496705 | 2016-07-14T11:18:37 | 2016-07-14T11:18:37 | 89,250,190 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,403 | java | package com.compta.firstak.notedefrais.Gestion_Salarie;
import android.app.Activity;
import android.app.DatePickerDialog;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.VolleyLog;
import com.android.volley.toolbox.JsonObjectRequest;
import com.compta.firstak.notedefrais.Gestion_Client.DashboardClient;
import com.compta.firstak.notedefrais.R;
import com.compta.firstak.notedefrais.adapter.SalarierAdapter;
import com.compta.firstak.notedefrais.adapter.UsersAdapter;
import com.compta.firstak.notedefrais.app.AppConfig;
import com.compta.firstak.notedefrais.app.AppController;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
/**
* Created by mohamed on 09/05/2016.
*/
public class Get_Salarier extends Activity{
Calendar myCalendar = Calendar.getInstance();
TextView adresse_edit,Situation_text,email_edit,fonction_edit,matricule_edit,NbrEnfant_edit,nom_edit,numCnss_edit,prenom_edit,salaireBrut_edit,situation_edit,DatePaie_edit,Cin_edit;
private RelativeLayout networkFailed;
String reqGetSalarie, TypeDactionnaire;
TextView NbreText;
Button actualiserbutton;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.get_salarier);
adresse_edit = (TextView) findViewById(R.id.Adressetext);
email_edit = (TextView) findViewById(R.id.Email_text);
fonction_edit = (TextView) findViewById(R.id.Fonction_text);
matricule_edit = (TextView) findViewById(R.id.MatriculeFiscale_text);
NbrEnfant_edit = (TextView) findViewById(R.id.NbrEnfant_text);
nom_edit = (TextView) findViewById(R.id.Nom_text);
numCnss_edit = (TextView) findViewById(R.id.CNSS_text);
prenom_edit = (TextView) findViewById(R.id.Prenom_text);
salaireBrut_edit = (TextView) findViewById(R.id.Salaire_text);
Cin_edit = (TextView) findViewById(R.id.CIN_text);
Situation_text= (TextView) findViewById(R.id.Situation_text);
DatePaie_edit = (TextView) findViewById(R.id.Date_text);
actualiserbutton = (Button) findViewById(R.id.button1);
networkFailed = (RelativeLayout) findViewById(R.id.network_failed);
NbrEnfant_edit = (TextView) findViewById(R.id.NbrEnfant_text);
NbreText = (TextView) findViewById(R.id.NbrEnfant);
GetSalarieJsonObject();
}
void GetSalarieJsonObject() {
actualiserbutton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
GetSalarieJsonObject();
}
});
if (isNetworkAvailable()) {
/* if (progressDialog==null)
{
progressDialog = MyCustomProgressDialog.ctor(Formulaire.this, "Chargement ... ");
progressDialog.show();
}*/
networkFailed.setVisibility(View.GONE);
// Tag used to cancel the request
Log.i("UrlGetFacture", AppConfig.getURLGetSalarierById(SalarierAdapter.idFromSelect));
JsonObjectRequest jsonObjReq = new JsonObjectRequest ( Request.Method.GET,
AppConfig.getURLGetSalarierById(SalarierAdapter.idFromSelect), null,
new Response.Listener<JSONObject>() {
@Override
public void onResponse(JSONObject FactureJsonFromJson) {
Log.d("RespWSGetSalarier", FactureJsonFromJson.toString());
try {
adresse_edit.setText(FactureJsonFromJson.get("adresse").toString());
email_edit.setText(FactureJsonFromJson.get("email").toString());
fonction_edit.setText(FactureJsonFromJson.get("fonction").toString());
matricule_edit.setText(FactureJsonFromJson.get("matricule").toString());
NbrEnfant_edit.setText(FactureJsonFromJson.get("nbrEnfant").toString());
nom_edit.setText(FactureJsonFromJson.get("nom").toString());
numCnss_edit.setText(FactureJsonFromJson.get("numCnss").toString());
prenom_edit.setText(FactureJsonFromJson.get("prenom").toString());
salaireBrut_edit.setText(FactureJsonFromJson.get("salaireBrut").toString());
DatePaie_edit.setText(FactureJsonFromJson.get("dateNaissance").toString());
Cin_edit.setText(FactureJsonFromJson.get("cin").toString());
Situation_text.setText(FactureJsonFromJson.get("situation").toString());
} catch (JSONException e) {
e.printStackTrace();
}
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
Log.i("ErrorMessageVolley","Error: "+error.getMessage());
VolleyLog.d("TAGVolley", "Error: " + error.getMessage());
/* progressDialog.dismiss();
progressDialog=null;*/
// hide the progress dialog
Animation animationTranslate = AnimationUtils.loadAnimation(getApplicationContext(),
R.anim.abc_slide_in_bottom);
networkFailed.startAnimation(animationTranslate);
networkFailed.setVisibility(View.VISIBLE);
}
});
// Adding request to request queue
AppController.getInstance().addToRequestQueue(jsonObjReq, reqGetSalarie);
} else {
Animation animationTranslate = AnimationUtils.loadAnimation(getApplicationContext(),
R.anim.abc_slide_in_bottom);
networkFailed.startAnimation(animationTranslate);
networkFailed.setVisibility(View.VISIBLE);
}
}
private boolean isNetworkAvailable() {
ConnectivityManager connectivityManager = (ConnectivityManager)
getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager
.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}
}
| [
"mohamedsahbi.nakhli@esprit.tn"
] | mohamedsahbi.nakhli@esprit.tn |
4ff7b327108003d9b5f0876af0cfef3d2ace46b4 | 96cc78ea8a91d3f404ec58c27a44757ed1529dbb | /AI - JAVA/src/AI/Fitness.java | 5748948e54fb28eae5072ffcd4f80ce83e4ba793 | [] | no_license | ArthurRab/EvolutionaryNeuralAI | 1fb64b69b2a875c8b454df3a0bb51cda5a5146f5 | 25446c7291175718d08818585851b8d6cebd6f2d | refs/heads/master | 2021-01-12T04:46:46.985957 | 2017-10-07T18:02:51 | 2017-10-07T18:02:51 | 77,794,178 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 158 | java | package AI;
public interface Fitness {
public float getFitness();
public void addToFitness(float f);
public void setFitness(float f);
}
| [
"saybe@192.168.0.19"
] | saybe@192.168.0.19 |
ea503c21d65e8a361b312e375932b3311223a34c | f5d5e585d48aa7209e74e3a07c35d4526b33b7f1 | /src/main/java/com/example/demo1/service/PersonServiceImpl.java | 96e133cdcc0d86a56d701b76750ae2314316e87c | [] | no_license | knowyouabc/demo1 | 9d720b3f0be2202c5250d7ee0890d4c00e2ac2bb | aa5dd3262546e404ac176fc862a5e46153cd3593 | refs/heads/master | 2020-07-23T13:18:17.518072 | 2019-09-10T13:42:18 | 2019-09-10T13:42:18 | 207,569,899 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 524 | java | package com.example.demo1.service;
import com.example.demo1.aspect.AnnAspect;
import org.springframework.stereotype.Service;
@Service
public class PersonServiceImpl implements PersonService {
PersonServiceImpl () {
System.out.println("+++++++");
}
@Override
public String getData(Long id) {
System.out.println("aaaaaa1");
return "111";
}
@AnnAspect
@Override
public String getData2(Long id) {
System.out.println("aaaaaa2");
return "222";
}
}
| [
"jxu17@best-inc.com"
] | jxu17@best-inc.com |
7a54c05ca0d4db85420fdf48cd82090226aad486 | 1fb19dffab7774e6e920a2c297f54a9a6b277c1f | /src/main/java/com/lambkit/db/datasource/DataSourcePasswordCracker.java | 89e208f2e8dcb28795c9070334ebfde24dddeb92 | [
"Apache-2.0"
] | permissive | gismaker/lambkit | 7bcb8ba9b5a8a754c551444e03f8b9bafc259dca | 1a3690a499380667be67b54f57eb62a82686cebf | refs/heads/master | 2023-04-30T22:33:58.563394 | 2022-03-27T07:03:18 | 2022-03-27T07:03:18 | 171,219,377 | 12 | 2 | Apache-2.0 | 2023-04-14T17:31:33 | 2019-02-18T05:18:25 | Java | UTF-8 | Java | false | false | 902 | java | package com.lambkit.db.datasource;
import com.jfinal.kit.StrKit;
import com.lambkit.common.LambkitPasswordCracker;
import com.lambkit.common.util.SecurityUtils;
public class DataSourcePasswordCracker implements LambkitPasswordCracker {
@Override
public String encode(String password, String salt) {
// TODO Auto-generated method stub
if(password==null)
return password;
if(StrKit.isBlank(salt)) {
return SecurityUtils.encodePassword(password);
} else {
return SecurityUtils.encodePassword(password, salt);
}
}
@Override
public String decode(String password, String salt) {
// TODO Auto-generated method stub
if(StrKit.isBlank(password) || password.length() < 24)
return password;
if(StrKit.isBlank(salt)) {
return SecurityUtils.decodePassword(password);
} else {
return SecurityUtils.decodePassword(password, salt);
}
}
}
| [
"DELL@DESKTOP-DK1FNRL"
] | DELL@DESKTOP-DK1FNRL |
b0daab71f448791046f859718dd73a35887dd67e | da3e8a631c366f43f162da23b68e4f4c16f700f4 | /src/main/java/Gitl.java | 3b5f5b7ff9157d37a63b566f7e92ab15b1ce78aa | [] | no_license | bbbbb1123/bbbbbbbbbbbb | 90e90b40ce74493c7328932825a1921110a6e2ef | ff096345792ef81eba6321a66abc583f7f9656cf | refs/heads/master | 2023-02-18T05:21:53.882554 | 2021-01-20T10:27:43 | 2021-01-20T10:27:43 | 331,271,192 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 47 | java | public class Gitl {
private String mae;
}
| [
"1600783592"
] | 1600783592 |
67460f7b1642e83dcccd0ff79f6c7d5de37c631d | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/2/2_23d97225e7e58a233dbbe929f4f8bd60f0837ae2/TableTripPattern/2_23d97225e7e58a233dbbe929f4f8bd60f0837ae2_TableTripPattern_s.java | f5510129a4011b891250450cf9dd62cd6b9add03 | [] | no_license | zhongxingyu/Seer | 48e7e5197624d7afa94d23f849f8ea2075bcaec0 | c11a3109fdfca9be337e509ecb2c085b60076213 | refs/heads/master | 2023-07-06T12:48:55.516692 | 2023-06-22T07:55:56 | 2023-06-22T07:55:56 | 259,613,157 | 6 | 2 | null | 2023-06-22T07:55:57 | 2020-04-28T11:07:49 | null | UTF-8 | Java | false | false | 10,794 | java | /* This program 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 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.opentripplanner.routing.edgetype;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlTransient;
import lombok.Delegate;
import org.onebusaway.gtfs.model.Stop;
import org.onebusaway.gtfs.model.Trip;
import org.opentripplanner.common.MavenVersion;
import org.opentripplanner.routing.core.RoutingRequest;
import org.opentripplanner.routing.core.ServiceDay;
import org.opentripplanner.routing.core.State;
import org.opentripplanner.routing.trippattern.TripTimes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Represents a class of trips distinguished by service id and list of stops. For each stop, there
* is a list of departure times, running times, arrival times, dwell times, and wheelchair
* accessibility information (one of each of these per trip per stop). An exemplar trip is also
* included so that information such as route name can be found. Trips are assumed to be
* non-overtaking, so that an earlier trip never arrives after a later trip.
*/
public class TableTripPattern implements TripPattern, Serializable {
private static final Logger LOG = LoggerFactory.getLogger(TableTripPattern.class);
private static final long serialVersionUID = MavenVersion.VERSION.getUID();
public static final int FLAG_WHEELCHAIR_ACCESSIBLE = 1;
public static final int MASK_PICKUP = 2|4;
public static final int SHIFT_PICKUP = 1;
public static final int MASK_DROPOFF = 8|16;
public static final int SHIFT_DROPOFF = 3;
public static final int NO_PICKUP = 1;
public static final int FLAG_BIKES_ALLOWED = 32;
/**
* An integer index uniquely identifying this pattern among all in the graph.
* This additional level of indirection allows versioning of trip patterns, which is
* necessary for real-time stop time updates. (Currently using a hashmap until that proves to
* be too inefficient.)
*/
// public final int patternIndex;
/** An arbitrary trip that uses this pattern. Maybe we should just store route, etc. directly. */
public final Trip exemplar;
/**
* This timetable holds the 'official' stop times from GTFS. If realtime stoptime updates are
* applied, trips searches will be conducted using another timetable and this one will serve to
* find early/late offsets, or as a fallback if the other timetable becomes corrupted or
* expires. Via Lombok Delegate, calling timetable methods on a TableTripPattern will call
* them on its scheduled timetable.
*/
@Delegate
protected final Timetable scheduledTimetable = new Timetable(this);
// redundant since tripTimes have a trip
// however it's nice to have for order reference, since all timetables must have tripTimes
// in this order, e.g. for interlining.
// potential optimization: trip fields can be removed from TripTimes?
/**
* This pattern may have multiple Timetable objects, but they should all contain TripTimes
* for the same trips, in the same order (that of the scheduled Timetable). An exception to
* this rule may arise if unscheduled trips are added to a Timetable. For that case we need
* to search for trips/TripIds in the Timetable rather than the enclosing TripPattern.
*/
final ArrayList<Trip> trips = new ArrayList<Trip>();
/**
* An ordered list of related PatternHop. All trips in a pattern have the same stops and a
* PatternHop apply to all those trips, so this array apply to every trip in every timetable in
* this pattern. Please note that the array size is the number of stops minus 1. This also allow
* to access the ordered list of stops.
*/
private PatternHop[] patternHops;
/** Holds stop-specific information such as wheelchair accessibility and pickup/dropoff roles. */
@XmlElement int[] perStopFlags;
/** Optimized serviceId code. All trips in a pattern are by definition on the same service. */
int serviceId;
public TableTripPattern(Trip exemplar, ScheduledStopPattern stopPattern, int serviceId) {
this.exemplar = exemplar;
this.serviceId = serviceId;
setStopsFromStopPattern(stopPattern);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
// The serialized graph contains cyclic references TableTripPattern <--> Timetable.
// The Timetable must be indexed from here (rather than in its own readObject method)
// to ensure that the stops field it uses in TableTripPattern is already deserialized.
this.scheduledTimetable.finish();
}
private void setStopsFromStopPattern(ScheduledStopPattern stopPattern) {
patternHops = new PatternHop[stopPattern.stops.size() - 1];
perStopFlags = new int[stopPattern.stops.size()];
int i = 0;
for (Stop stop : stopPattern.stops) {
if (stop.getWheelchairBoarding() == 1) {
perStopFlags[i] |= FLAG_WHEELCHAIR_ACCESSIBLE;
}
perStopFlags[i] |= stopPattern.pickups.get(i) << SHIFT_PICKUP;
perStopFlags[i] |= stopPattern.dropoffs.get(i) << SHIFT_DROPOFF;
++i;
}
}
private Stop getStop(int stopIndex) {
if (stopIndex == patternHops.length)
return patternHops[stopIndex - 1].getEndStop();
else
return patternHops[stopIndex].getStartStop();
}
public List<Stop> getStops() {
/*
* Dynamically build the list from the PatternHop list. Not super efficient but this method
* is not called very often.
*/
List<Stop> retval = new ArrayList<Stop>(patternHops.length + 1);
for (int i = 0; i < patternHops.length; i++)
retval.add(getStop(i));
return retval;
}
public List<PatternHop> getPatternHops() {
return Arrays.asList(patternHops);
}
/* package private */
void setPatternHop(int stopIndex, PatternHop patternHop) {
patternHops[stopIndex] = patternHop;
}
@Override
public int getHopCount() {
return patternHops.length;
}
public Trip getTrip(int tripIndex) {
return trips.get(tripIndex);
}
@XmlTransient
public List<Trip> getTrips() {
return trips;
}
public int getTripIndex(Trip trip) {
return trips.indexOf(trip);
}
/** Returns whether passengers can alight at a given stop */
public boolean canAlight(int stopIndex) {
return getAlightType(stopIndex) != NO_PICKUP;
}
/** Returns whether passengers can board at a given stop */
public boolean canBoard(int stopIndex) {
return getBoardType(stopIndex) != NO_PICKUP;
}
/** Returns the zone of a given stop */
public String getZone(int stopIndex) {
return getStop(stopIndex).getZoneId();
}
/** Returns an arbitrary trip that uses this pattern */
public Trip getExemplar() {
return exemplar;
}
public int getAlightType(int stopIndex) {
return (perStopFlags[stopIndex] & MASK_DROPOFF) >> SHIFT_DROPOFF;
}
public int getBoardType(int stopIndex) {
return (perStopFlags[stopIndex] & MASK_PICKUP) >> SHIFT_PICKUP;
}
/**
* Gets the number of scheduled trips on this pattern. Note that when stop time updates are
* being applied, there may be other Timetables for this pattern which contain a larger number
* of trips. However, all trips with indexes from 0 through getNumTrips()-1 will always
* correspond to the scheduled trips.
*/
public int getNumScheduledTrips () {
return trips.size();
}
// TODO: Lombokize all boilerplate... but lombok does not generate javadoc :/
public int getServiceId() {
return serviceId;
}
/**
* Find the next (or previous) departure on this pattern at or after (respectively before) the
* specified time. This method will make use of any TimetableResolver present in the
* RoutingContext to redirect departure lookups to the appropriate updated Timetable, and will
* fall back on the scheduled timetable when no updates are available.
* @param boarding true means find next departure, false means find previous arrival
* @return a TripTimes object providing all the arrival and departure times on the best trip.
*/
public TripTimes getNextTrip(int stopIndex, int time, State state0, ServiceDay sd,
boolean haveBicycle, boolean boarding) {
RoutingRequest options = state0.getOptions();
Timetable timetable = scheduledTimetable;
TimetableResolver snapshot = options.rctx.timetableSnapshot;
if (snapshot != null)
timetable = snapshot.resolve(this);
// check that we can even board/alight the given stop on this pattern with these options
int mask = boarding ? MASK_PICKUP : MASK_DROPOFF;
int shift = boarding ? SHIFT_PICKUP : SHIFT_DROPOFF;
int stopOffset = boarding ? 0 : 1;
if ((perStopFlags[stopIndex + stopOffset] & mask) >> shift == NO_PICKUP) {
return null;
}
if (options.wheelchairAccessible &&
(perStopFlags[stopIndex + stopOffset] & FLAG_WHEELCHAIR_ACCESSIBLE) == 0) {
return null;
}
// so far so good, delegate to the timetable
return timetable.getNextTrip(stopIndex, time, state0, sd, haveBicycle, boarding);
}
public Iterator<Integer> getScheduledDepartureTimes(int stopIndex) {
return scheduledTimetable.getDepartureTimes(stopIndex);
}
}
| [
"yuzhongxing88@gmail.com"
] | yuzhongxing88@gmail.com |
48915eb95b33c29982d358dbf78994ff3b95d815 | 2e9289609edff7ce6b18a5d41da6490c0dd75cf2 | /TP06/src/main/java/HumanClient.java | 36dfc252ac5fea28465940282b9cd678ab552bc6 | [] | no_license | Homailot/FEUP-LPOO | 9a9e9be25d5ffff28a293ac1832375ba83844442 | 69c497714f331789e4ac09d6dbcf80173ada272b | refs/heads/master | 2023-04-02T22:06:04.940925 | 2021-03-31T17:08:57 | 2021-03-31T17:08:57 | 341,851,866 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 522 | java | public class HumanClient implements Client{
private OrderingStrategy strategy;
HumanClient(OrderingStrategy strategy) {
this.strategy = strategy;
}
@Override
public void happyHourStarted(Bar bar) {
strategy.happyHourStarted(bar);
}
@Override
public void happyHourEnded(Bar bar) {
strategy.happyHourEnded(bar);
}
@Override
public void wants(StringDrink drink, StringRecipe recipe, StringBar bar) {
strategy.wants(drink, recipe, bar);
}
}
| [
"nyansword@gmail.com"
] | nyansword@gmail.com |
ca38f05d66ae71994b4b5c795c48c8e04a9b45c3 | 7d9946a9768d268bd5a900f85d27af133567d59a | /app/src/main/java/com/example/uasmp/TambahPinjam.java | 0de2ab9cc71e798de7459e8226b15f9d2865ef3a | [] | no_license | ApolinarisEdiusRadho/UASMP | 73dc030c4f3c82e4b6d3721f216f5ddc161c25fb | 333516bd2d886bedb755fec98599805f715a1c0c | refs/heads/master | 2022-11-15T18:02:13.684819 | 2020-06-24T06:08:35 | 2020-06-24T06:08:35 | 274,160,177 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,419 | java | package com.example.uasmp;
import androidx.appcompat.app.AppCompatActivity;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
public class TambahPinjam extends AppCompatActivity {
sqlpinjam dbHelper;
Button btntambahpinjam;
EditText txtnim, txtnamamahasiswa, txtjudulbuku, txtpinjam,txtkembali,txttelepon,txtalamat;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tambah_pinjam);
getSupportActionBar().setTitle("Tambah Data Peminjam");
dbHelper = new sqlpinjam(this);
txtnim = (EditText)findViewById(R.id.txtnim);
txtnamamahasiswa = (EditText)findViewById(R.id.txtnamamahasiswa);
txtjudulbuku = (EditText)findViewById(R.id.txtjudulbuku);
txtpinjam = (EditText)findViewById(R.id.txtpinjam);
txtkembali = (EditText)findViewById(R.id.txtkembali);
txttelepon = (EditText)findViewById(R.id.txttelepon);
txtalamat = (EditText)findViewById(R.id.txtalamat);
btntambahpinjam = (Button)findViewById(R.id.btntambahpinjam);
btntambahpinjam.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
SQLiteDatabase db = dbHelper.getWritableDatabase();
String sql = "INSERT INTO pinjam (nim, nama_mahasiswa, judul_buku, tgl_pinjam, tgl_kembali, no_telp, alamat)" +
" VALUES ('"+ txtnim.getText().toString() +"'," +
" '"+ txtnamamahasiswa.getText().toString() +"'," +
" '"+ txtjudulbuku.getText().toString() +"'," +
" '"+ txtpinjam.getText().toString() +"'," +
" '"+ txtkembali.getText().toString() +"'," +
" '"+ txttelepon.getText().toString() +"'," +
" '"+ txtalamat.getText().toString() +"')";
db.execSQL(sql);
Toast.makeText(getApplicationContext(),"Berhasil Menambahkan Data", Toast.LENGTH_LONG).show();
DataPeminjaman.bd.RefreshList();
finish();
}
});
}
}
| [
"ardianradho97@gmail.com"
] | ardianradho97@gmail.com |
36868d5a4883f005341c11b96b14fe23ba796d99 | f1596507ea50d9e43336b3d090452617b906729a | /src/main/java/com/przeskocz/AdvertEduPortal/model/University.java | 6931d43be41aea993f1f6a957aee87d404a59389 | [] | no_license | Przeskocz/AdvertEduPortal | 13ddd0836d1fc6a3ffba16983f8b1bbc51bb432a | 092c0388feb2c1f150dd141010bf110701200388 | refs/heads/master | 2022-11-09T01:10:01.663235 | 2020-06-20T08:29:19 | 2020-06-20T08:29:19 | 264,293,825 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 690 | java | package com.przeskocz.AdvertEduPortal.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
public class University implements Comparable<University> {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String shortName;
@ManyToOne()
private City city;
public University(String name, String shortName, City city) {
this(-1L, name, shortName, city);
}
@Override
public int compareTo(University o) {
return this.getName().compareTo(o.getName());
}
}
| [
"skoczp@gmail.com"
] | skoczp@gmail.com |
af947d88878f1d3953c8620dd32d4243f223ce99 | 2a7012b192d9ddbd9e51c3c7ba0a0d636c59d61d | /auth-service/src/main/java/com/sid/authservice/sec/service/UserDetailsServiceImpl.java | dd6b454fac56cb941e3d2529e0a57b0777896f47 | [] | no_license | asmaesaid1010/projet-jee | 0a44afe04d612e510dbafaa77ae55889b56ffb14 | 5f32277417974764f8167ae5ae32add750fd21dc | refs/heads/main | 2023-03-12T11:12:33.391247 | 2021-02-20T18:23:39 | 2021-02-20T18:23:39 | 340,723,489 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,738 | java | package com.sid.authservice.sec.service;
import com.sid.authservice.sec.entites.AppUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Collection;
import java.util.stream.Collectors;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
private AccountService accountService;
public UserDetailsServiceImpl(AccountService accountService) {
this.accountService = accountService;
}
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
AppUser appUser = accountService.loadUserByUsername(username);
//if (appUser == null) throw new UsernameNotFoundException("invalid user");
/* Collection<GrantedAuthority> authorities = new ArrayList<>();
appUser.getAppRoles().forEach(r -> {
authorities.add(new SimpleGrantedAuthority(r.getRoleName()));
});*/
Collection<GrantedAuthority> authorities = appUser.getAppRoles().stream().map(r -> new SimpleGrantedAuthority(r.getRoleName())).collect(Collectors.toList());
User user = new User(appUser.getUsername(), appUser.getPassword(), authorities);
return user;
}
}
| [
"asmae.said1010@gmail.com"
] | asmae.said1010@gmail.com |
da309f58f6bb25113de3fdaea08e7fcd4f6bcf7c | 3c5caeb7f3d983d20796f42d1e9f0a5ddf30ea06 | /backend/src/main/java/br/com/sisdb/dscatalog/entities/User.java | 0ef61c8d532b35671c0ce61c4385ea57af2951b8 | [] | no_license | danielbortolozo/dscatalog-bootcamp-devsuperior | e45ed086efa06c03af4ed3d628915dde5e3ef066 | 9dfa6065c261c04106695237a6036d1b7204210f | refs/heads/master | 2023-04-21T05:46:42.257948 | 2021-02-19T03:59:35 | 2021-02-19T03:59:35 | 330,244,104 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,261 | java | package br.com.sisdb.dscatalog.entities;
import com.fasterxml.jackson.annotation.JsonIgnore;
import javax.persistence.*;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
@Entity
@Table(name = "user")
public class User implements Serializable {
private static final long serialVersionUID =1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String firstName;
private String lastName;
@Column(unique = true)
private String email;
private String password;
@JsonIgnore
@ManyToMany(fetch = FetchType.EAGER)
@JoinTable(name = "user_role",
joinColumns = @JoinColumn(name = "user_id"),
inverseJoinColumns = @JoinColumn(name = "role_id"))
private Set<Role> roles = new HashSet<>();
public User() {
}
public User(Long id, String firstName, String lastName, String email, String password) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
this.password = password;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Set<Role> getRoles() {
return roles;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return id.equals(user.id);
}
@Override
public int hashCode() {
return Objects.hash(id);
}
}
| [
"danielbortolozo@hotmail.com"
] | danielbortolozo@hotmail.com |
cb977c48e74c68e9b2c21909eb7e51658aceef29 | 8b589bac78a18f30b95697e5bc1bed861d96fbc9 | /app/src/test/java/com/example/yvtc/s050402/ExampleUnitTest.java | 1e21bb56019f5f4f53e3c4e78ea576e80d4c3c93 | [] | no_license | dannielccw/S050402 | 63a2008fa27aef669398f935dd152fdd4b27604c | 4b76c18383296b3a80bcdbcb6533f32614e61c4e | refs/heads/master | 2021-01-20T09:09:17.640919 | 2017-05-04T07:03:25 | 2017-05-04T07:03:25 | 90,228,694 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 402 | java | package com.example.yvtc.s050402;
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);
}
} | [
"dannielccw@gmail.com"
] | dannielccw@gmail.com |
0e02144cf719519cdf67faf39c72c24dcd605431 | 884e5995036d4642f3da98abdf009a31345f5d49 | /CyHCEBluetooth/src/com/laalaguer/pcda/TagWrapper.java | 0447bbfb398339b2f46344dec811eff4e84c34d4 | [] | no_license | bir0bin/HCE-NFC-Relay-Attack | b0b468e5cefcab55c1c87f77c5b5debf40ae291f | 7fe0612d856bdfa38e91678b788e435e1cc57d25 | refs/heads/master | 2021-01-17T01:09:32.846210 | 2014-03-08T19:30:02 | 2014-03-08T19:30:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,021 | java | package com.laalaguer.pcda;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import android.nfc.Tag;
import android.nfc.tech.TagTechnology;
/**
* This is a wrapper class.
* This class will return public methods to access an NFC reader (IsoPcdA or others).
* See the public methods as references.
* @author Xiqing Chu
*
*/
public class TagWrapper implements TagTechnology {
private Method isConnected;
private Method connect;
private Method reconnect;
private Method close;
private Method getMaxTransceiveLength;
private Method transceive;
private Tag tag;
private Object tagTech;
public TagWrapper(Tag tag, String tech) {
try {
this.tag = tag;
Class<?> cls = Class.forName(tech);
Method get = cls.getMethod("get", Tag.class);
tagTech = get.invoke(null, tag); // get(Tag tag) is a static function
isConnected = cls.getMethod("isConnected");
connect = cls.getMethod("connect");
reconnect = cls.getMethod("reconnect");
close = cls.getMethod("close");
getMaxTransceiveLength = cls.getMethod("getMaxTransceiveLength");
transceive = cls.getMethod("transceive", byte[].class);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsRE(e);
}
}
private void throwCauseAsRE(InvocationTargetException e) {
if (e.getTargetException() != null) {
throw new RuntimeException(e.getTargetException());
}
throw new RuntimeException(e);
}
private void throwCauseAsIOE(InvocationTargetException e)
throws IOException {
if (e.getTargetException() != null) {
if (e.getTargetException() instanceof IOException) {
throw (IOException) e.getTargetException();
} else {
throw new RuntimeException(e.getTargetException());
}
}
throw new RuntimeException(e);
}
@Override
public boolean isConnected() {
boolean result = false;
try {
return (Boolean) isConnected.invoke(tagTech);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsRE(e);
}
return result;
}
@Override
public void connect() throws IOException {
try {
connect.invoke(tagTech);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsIOE(e);
}
}
// @Override @hide-n, so can't use annotation
public void reconnect() throws IOException {
try {
reconnect.invoke(tagTech);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsIOE(e);
}
}
@Override
public void close() throws IOException {
try {
close.invoke(tagTech);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsIOE(e);
}
}
public int getMaxTransceiveLength() {
try {
return (Integer) getMaxTransceiveLength.invoke(tagTech);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsRE(e);
}
return 0;
}
public byte[] transceive(byte[] data) throws IOException {
try {
return (byte[]) transceive.invoke(tagTech, data);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throwCauseAsIOE(e);
}
throw new IOException("transceive failed");
}
@Override
public Tag getTag() {
return tag;
}
}
| [
"laalaguer@gmail.com"
] | laalaguer@gmail.com |
e51964bfc17dda276fe8cd5a148e181cb9348941 | 0abbf5dca719992b75bf975b752578e4b88dac52 | /src/main/java/edu/olezha/jsandbox/core/date/sqlDate/Main.java | a9ccab7528f51da886fe8d656984e516ef119aea | [
"MIT"
] | permissive | devalexk/test | 80aeeafc1eac362bd1ac781ec8864dffb0c90d08 | 9bea82f0e06595017389bd4e70302dc93605e4ae | refs/heads/master | 2020-04-26T03:59:42.499683 | 2019-03-01T12:16:02 | 2019-03-01T12:16:02 | 173,286,032 | 0 | 1 | MIT | 2019-04-08T10:26:08 | 2019-03-01T10:50:58 | Java | UTF-8 | Java | false | false | 2,158 | java | package edu.olezha.jsandbox.core.date.sqlDate;
import lombok.extern.slf4j.Slf4j;
import java.sql.*;
@Slf4j
public class Main {
private static final String CREATE_TABLE_SQL =
"create table if not exists date_of (id int primary key auto_increment, date_of date, time_of time, timestamp_of timestamp)";
private static final String WRITE_DATE_SQL =
"insert into date_of (date_of, time_of, timestamp_of) values(?, ?, ?)";
private static final String SELECT_ALL = "select * from date_of";
public static void main(String... args) throws Exception {
Class.forName("org.h2.Driver");
Main main = new Main();
main.createTable();
main.writeDate(new java.util.Date());
main.printAll();
}
private void createTable() throws SQLException {
try (Connection connection = getConnection();
Statement statement = connection.createStatement()) {
statement.execute(CREATE_TABLE_SQL);
}
}
private void writeDate(java.util.Date date) throws SQLException {
try (Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement(WRITE_DATE_SQL)) {
statement.setDate(1, new java.sql.Date(date.getTime()));
statement.setTime(2, new java.sql.Time(date.getTime()));
statement.setTimestamp(3, new java.sql.Timestamp(date.getTime()));
statement.executeUpdate();
}
}
private void printAll() throws SQLException {
try (Connection connection = getConnection();
Statement statement = connection.createStatement()) {
ResultSet resultSet = statement.executeQuery(SELECT_ALL);
while (resultSet.next())
log.info("{} | {} | {} | {}",
resultSet.getString(1),
resultSet.getString(2),
resultSet.getString(3),
resultSet.getString(4));
}
}
private Connection getConnection() throws SQLException {
return DriverManager.getConnection("jdbc:h2:./data");
}
}
| [
"pio_ua@ukr.net"
] | pio_ua@ukr.net |
53c5eec825ce0d9a422b50c10b2063b751722e58 | fa1408365e2e3f372aa61e7d1e5ea5afcd652199 | /src/testcases/CWE129_Improper_Validation_of_Array_Index/s04/CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81a.java | fd9acd5b63ab2d5d17d8ab7d86a3fcc0dadf6bf7 | [] | no_license | bqcuong/Juliet-Test-Case | 31e9c89c27bf54a07b7ba547eddd029287b2e191 | e770f1c3969be76fdba5d7760e036f9ba060957d | refs/heads/master | 2020-07-17T14:51:49.610703 | 2019-09-03T16:22:58 | 2019-09-03T16:22:58 | 206,039,578 | 1 | 2 | null | null | null | null | UTF-8 | Java | false | false | 3,899 | java | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81a.java
Label Definition File: CWE129_Improper_Validation_of_Array_Index.label.xml
Template File: sources-sinks-81a.tmpl.java
*/
/*
* @description
* CWE: 129 Improper Validation of Array Index
* BadSource: Property Read data from a system property
* GoodSource: A hardcoded non-zero, non-min, non-max, even number
* Sinks: array_write_no_check
* GoodSink: Write to array after verifying index
* BadSink : Write to array without any verification of index
* Flow Variant: 81 Data flow: data passed in a parameter to an abstract method
*
* */
package testcases.CWE129_Improper_Validation_of_Array_Index.s04;
import testcasesupport.*;
import javax.servlet.http.*;
import java.util.logging.Level;
public class CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81a extends AbstractTestCase
{
public void bad() throws Throwable
{
int data;
data = Integer.MIN_VALUE; /* Initialize data */
/* get system property user.home */
/* POTENTIAL FLAW: Read data from a system property */
{
String stringNumber = System.getProperty("user.home");
try
{
data = Integer.parseInt(stringNumber.trim());
}
catch(NumberFormatException exceptNumberFormat)
{
IO.logger.log(Level.WARNING, "Number format exception parsing data from string", exceptNumberFormat);
}
}
CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_base baseObject = new CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_bad();
baseObject.action(data );
}
public void good() throws Throwable
{
goodG2B();
goodB2G();
}
/* goodG2B() - use GoodSource and BadSink */
private void goodG2B() throws Throwable
{
int data;
/* FIX: Use a hardcoded number that won't cause underflow, overflow, divide by zero, or loss-of-precision issues */
data = 2;
CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_base baseObject = new CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_goodG2B();
baseObject.action(data );
}
/* goodB2G() - use BadSource and GoodSink */
private void goodB2G() throws Throwable
{
int data;
data = Integer.MIN_VALUE; /* Initialize data */
/* get system property user.home */
/* POTENTIAL FLAW: Read data from a system property */
{
String stringNumber = System.getProperty("user.home");
try
{
data = Integer.parseInt(stringNumber.trim());
}
catch(NumberFormatException exceptNumberFormat)
{
IO.logger.log(Level.WARNING, "Number format exception parsing data from string", exceptNumberFormat);
}
}
CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_base baseObject = new CWE129_Improper_Validation_of_Array_Index__Property_array_write_no_check_81_goodB2G();
baseObject.action(data );
}
/* Below is the main(). It is only used when building this testcase on
* its own for testing or for building a binary to use in testing binary
* analysis tools. It is not used when compiling all the testcases as one
* application, which is how source code analysis tools are tested.
*/
public static void main(String[] args) throws ClassNotFoundException,
InstantiationException, IllegalAccessException
{
mainFromParent(args);
}
}
| [
"bqcuong2212@gmail.com"
] | bqcuong2212@gmail.com |
fe66d366fbf00fcc7120959974b04f4e3dbb8035 | 32a6187b3d09211eb527cfe5ee8faad600193f3e | /admin/src/main/java/com/tjufe/admin/AdminApplication.java | b7a813acdfc368e88f5853e01e31b89be3ef8305 | [] | no_license | doublefunction/waimai | 504bb2b984b1bd241e38d6b8ec37248b3b2499bc | 5b97fa69b21e8091ac8fcc45442f29881f77d508 | refs/heads/master | 2020-04-27T10:22:15.824708 | 2019-03-07T03:07:16 | 2019-03-07T03:07:16 | 174,250,710 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 318 | java | package com.tjufe.admin;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class AdminApplication {
public static void main(String[] args) {
SpringApplication.run(AdminApplication.class, args);
}
}
| [
"zhangyuhang@leimingtech.com"
] | zhangyuhang@leimingtech.com |
0100d876f63e896319bf1238a91354720ddb101b | 8eab4b2ce8a47c9f9790ec5d2e7d32bb73c2a804 | /Generator/src/org/ludo/codegenerator/xml/core/gen/core/bean/IGenTemplateGroupesRefPourGenererParTemplate.java | 5e75e7d336d78d2bd8ba50dfed342ac6a8e4bf74 | [
"Artistic-2.0"
] | permissive | ludo1026/tuto | 0ed1589fb671e26a0ab139f0a21815fec63c835e | ec7fb220ff59395f140f076ef3388196df985341 | refs/heads/master | 2021-01-21T21:40:14.107395 | 2014-02-20T06:33:56 | 2014-02-20T06:33:56 | 14,284,254 | 0 | 1 | null | 2016-03-09T22:44:13 | 2013-11-10T20:58:42 | Java | UTF-8 | Java | false | false | 1,142 | java | package org.ludo.codegenerator.xml.core.gen.core.bean;
import java.util.List;
public interface GenTemplateGroupesRefPourGenererParTemplate {
/** Récupération de l'élément parent */
public GenGenererParTemplate getReferenceGenGenererParTemplate();
public void setReferenceGenGenererParTemplate(GenGenererParTemplate referenceGenGenererParTemplate);
/** Récupération des éléments fils */
public GenTemplateGroupeRefPourGenererParTemplate getGenTemplateGroupeRefPourGenererParTemplateByTemplateGroupeNom(String templateGroupeNom);
public void addGenTemplateGroupeRefPourGenererParTemplate(GenTemplateGroupeRefPourGenererParTemplate genTemplateGroupeRefPourGenererParTemplate);
public List<GenTemplateGroupeRefPourGenererParTemplate> getListeGenTemplateGroupeRefPourGenererParTemplate();
public void setListeGenTemplateGroupeRefPourGenererParTemplate(List<GenTemplateGroupeRefPourGenererParTemplate> listeGenTemplateGroupeRefPourGenererParTemplate);
/** Récupération des attributs de l'objet de base sans transtypage */
/** Récupération des attributs de l'objet de base avec transtypage */
}
| [
"l.chaboud@gmail.com"
] | l.chaboud@gmail.com |
a27900ec18ed8d309b3208a2c105a0f5cfc3182e | 29aa41c880e7a326ec7f8ae9bf4f0c3bb3ea2e90 | /src/test/java/Apalya/CMS_Sunnxt/AppTest.java | eb55103d11f8d9848b47650ab6194123fbbf21f3 | [] | no_license | kiran51190/SUNCMS | 9e3c0173476dd994cc3362c18f288b9241943bb4 | 2ff364e8124d4148848f52ab90878e8b321c5277 | refs/heads/master | 2023-06-25T17:28:49.032432 | 2021-07-29T06:12:18 | 2021-07-29T06:12:18 | 390,355,332 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 645 | java | package Apalya.CMS_Sunnxt;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp()
{
assertTrue( true );
}
}
| [
"challakiran51190@gamil.com"
] | challakiran51190@gamil.com |
1b915578ac323c1a40921b6d930244c19c419b10 | 298db8ecbc79f4eab69797d8058645aa5141f81c | /microservicecloud-consumer-dept-80/src/main/java/com/atguigu/myrule/MySelfRule.java | 15306a5827b97342d050735891a5519c385dbb92 | [] | no_license | guo521jun/microservicecloud | 3f972604a61185c71dbe0e6492aaf2d97122ebcd | b258966a9d1dc29f407bdeded66f1b516991d7dc | refs/heads/master | 2020-03-18T14:31:00.616927 | 2018-05-25T12:15:15 | 2018-05-25T12:15:15 | 134,852,355 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 332 | java | package com.atguigu.myrule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.netflix.loadbalancer.IRule;
@Configuration
public class MySelfRule {
/**
* 自定义负载均衡算法
*/
@Bean
public IRule iRule() {
return new MyRandomRule();
}
}
| [
"18591614160@163.com"
] | 18591614160@163.com |
d881c73b3f2519ec97d48e87b67b544cf415b197 | 6285b21026fbec3e4cdd694479b2a9aff5e3d0dc | /src/main/java/com/afeng/common/utils/BeanValidators.java | c5f5e4dce1ce8237d1b0b222c397b8a34ebe6912 | [] | no_license | bianyf1986/framework | 6343a4ba4da8302a32b23b4d060e8b1f70fcfd55 | 5d1ee2572d602803f8363568f5c70703eb70c057 | refs/heads/master | 2021-01-01T18:07:06.049407 | 2017-01-06T05:48:29 | 2017-01-06T05:48:29 | 78,176,476 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,317 | java | /**
* Copyright (c) 2015-2018
* @author afeng 416352221@qq.com
*/
package com.afeng.common.utils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Validator;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
/**
*
* @Description : JSR303 Validator(Hibernate Validator)工具类.
* ConstraintViolation中包含propertyPath, message 和invalidValue等信息.
* 提供了各种convert方法，适合不同的i18n需求:
* 1. List<String>, String内容为message
* 2. List<String>, String内容为propertyPath + separator + message
* 3. Map<propertyPath, message>
*
* 详情见wiki: https://github.com/springside/springside4/wiki/HibernateValidator
* @Date : 2015-7-7
* @author : afeng
* @Email : 41635221@qq.com
*/
public class BeanValidators {
/**
* 调用JSR303的validate方法, 验证失败时抛出ConstraintViolationException.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void validateWithException(Validator validator, Object object, Class<?>... groups)
throws ConstraintViolationException {
Set constraintViolations = validator.validate(object, groups);
if (!constraintViolations.isEmpty()) {
throw new ConstraintViolationException(constraintViolations);
}
}
/**
* 辅助方法, 转换ConstraintViolationException中的Set<ConstraintViolations>中为List<message>.
*/
public static List<String> extractMessage(ConstraintViolationException e) {
return extractMessage(e.getConstraintViolations());
}
/**
* 辅助方法, 转换Set<ConstraintViolation>为List<message>
*/
@SuppressWarnings("rawtypes")
public static List<String> extractMessage(Set<? extends ConstraintViolation> constraintViolations) {
List<String> errorMessages = Lists.newArrayList();
for (ConstraintViolation violation : constraintViolations) {
errorMessages.add(violation.getMessage());
}
return errorMessages;
}
/**
* 辅助方法, 转换ConstraintViolationException中的Set<ConstraintViolations>为Map<property, message>.
*/
public static Map<String, String> extractPropertyAndMessage(ConstraintViolationException e) {
return extractPropertyAndMessage(e.getConstraintViolations());
}
/**
* 辅助方法, 转换Set<ConstraintViolation>为Map<property, message>.
*/
@SuppressWarnings("rawtypes")
public static Map<String, String> extractPropertyAndMessage(Set<? extends ConstraintViolation> constraintViolations) {
Map<String, String> errorMessages = Maps.newHashMap();
for (ConstraintViolation violation : constraintViolations) {
errorMessages.put(violation.getPropertyPath().toString(), violation.getMessage());
}
return errorMessages;
}
/**
* 辅助方法, 转换ConstraintViolationException中的Set<ConstraintViolations>为List<propertyPath message>.
*/
public static List<String> extractPropertyAndMessageAsList(ConstraintViolationException e) {
return extractPropertyAndMessageAsList(e.getConstraintViolations(), " ");
}
/**
* 辅助方法, 转换Set<ConstraintViolations>为List<propertyPath message>.
*/
@SuppressWarnings("rawtypes")
public static List<String> extractPropertyAndMessageAsList(Set<? extends ConstraintViolation> constraintViolations) {
return extractPropertyAndMessageAsList(constraintViolations, " ");
}
/**
* 辅助方法, 转换ConstraintViolationException中的Set<ConstraintViolations>为List<propertyPath +separator+ message>.
*/
public static List<String> extractPropertyAndMessageAsList(ConstraintViolationException e, String separator) {
return extractPropertyAndMessageAsList(e.getConstraintViolations(), separator);
}
/**
* 辅助方法, 转换Set<ConstraintViolation>为List<propertyPath +separator+ message>.
*/
@SuppressWarnings("rawtypes")
public static List<String> extractPropertyAndMessageAsList(Set<? extends ConstraintViolation> constraintViolations,
String separator) {
List<String> errorMessages = Lists.newArrayList();
for (ConstraintViolation violation : constraintViolations) {
errorMessages.add(violation.getPropertyPath() + separator + violation.getMessage());
}
return errorMessages;
}
} | [
"416352221@qq.com"
] | 416352221@qq.com |
621533590008d37f526e6eb4d8626742a170852f | d68f47846c9809ecb5058ae2699de8c4e1434346 | /app/src/main/java/com/example/hp/maps/model/GarduIndukApi.java | f25a92a0345c5d38cbb998c86f7a67d53513860b | [] | no_license | umarkotak/android_gmaptest | c2a442565f7b96a275c946b2cc9c8a3936bd691a | b4a47a8307890ec7b3401c46718f4f27b2a54ddd | refs/heads/master | 2021-04-15T18:44:28.162633 | 2018-03-26T16:38:06 | 2018-03-26T16:38:06 | 126,849,259 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 252 | java | package com.example.hp.maps.model;
import java.util.List;
import retrofit2.Call;
import retrofit2.http.GET;
/**
* Created by admin on 26/03/18.
*/
public interface GarduIndukApi {
@GET("/map")
Call<List<GarduInduk>> getAllGarduInduk();
}
| [
"umar.ramadhana@aux-gojek.com"
] | umar.ramadhana@aux-gojek.com |
a98b6f61de148d564a234c79efbbc6ee8fc3fad8 | 7520983355d2e799bdde459e4a8737dab1c1afcf | /eclipse-workspace/JavaProgrammer/src/com/class2/AdditionVsConcatanation.java | 3461a8064a8ca15beb0f21a37517d955b36f8f99 | [] | no_license | gul1010/class2 | 0dfdc36ea83ca7857bd3b90b99b64dcbe0446295 | 35671775f4e89f01674993281e121d91a20b9024 | refs/heads/main | 2023-03-18T18:40:45.077815 | 2021-03-15T23:32:50 | 2021-03-15T23:32:50 | 348,152,473 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 367 | java | package com.class2;
public class AdditionVsConcatanation {
public static void main(String[] args) {
int num1=10;
int num2=20;
String n1="Hi";
String n2="Hey";
System.out.println(num1+num2+n1+n2);
System.out.println(num1+n1+num2+n2);
System.out.println(n1+n2+num1+num2);
String result=n1+n2+(num1+num2);
System.out.println(result);
}
}
| [
"gulichka_rd@yahoo.com"
] | gulichka_rd@yahoo.com |
893678f1b708d25fe62201098a95e7d12c4a4934 | 6a0c54d6a0372254763a4cae2ef9fb84e3dde530 | /test/de/caluga/test/mongo/suite/ComplexTest.java | d0d5ba6bf43deccbba64fbf24511f68acb7401bc | [] | no_license | sksundaram-learning/morphium | b4bbbb7df7d86e01a0def4db673e0274c1e0f90b | 6d962f531fcef274190215308d669ea64296be7d | refs/heads/master | 2021-01-22T14:55:28.394321 | 2017-05-17T08:46:14 | 2017-05-17T08:46:14 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,208 | java | package de.caluga.test.mongo.suite;
import de.caluga.morphium.Utils;
import de.caluga.morphium.query.Query;
import de.caluga.test.mongo.suite.data.EmbeddedObject;
import de.caluga.test.mongo.suite.data.UncachedObject;
import org.junit.Test;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* User: Stpehan Bösebeck
* Date: 29.03.12
* Time: 15:56
* <p>
* testing compley queryies on Morphium
*/
public class ComplexTest extends MongoTest {
@Test
public void testStoreAndRead() {
UncachedObject o = new UncachedObject();
o.setCounter(111);
o.setValue("Embedded object");
//morphium.store(o);
EmbeddedObject eo = new EmbeddedObject();
eo.setName("Embedded object 1");
eo.setValue("A value");
eo.setTest(System.currentTimeMillis());
ComplexObject co = new ComplexObject();
co.setEmbed(eo);
co.setEntityEmbeded(o);
UncachedObject ref = new UncachedObject();
ref.setCounter(100);
ref.setValue("The reference");
morphium.store(ref);
co.setRef(ref);
co.setEinText("This is a very complex object");
morphium.store(co);
//object stored!!!
waitForWrites();
//now read it again...
Query<ComplexObject> q = morphium.createQueryFor(ComplexObject.class);
ComplexObject co2 = q.getById(co.getId());
log.info("Just loaded: " + co2.toString());
log.info("Stored : " + co.toString());
assert (co2.getId().equals(co.getId())) : "Ids not equal?";
}
@Test
public void testAccessTimestamps() {
ComplexObject o = new ComplexObject();
o.setEinText("A test");
o.setTrans("Tansient");
o.setNullValue(15);
//And test for null-References!
morphium.store(o);
assert (o.getChanged() != 0) : "Last change not set!?!?";
Query<ComplexObject> q = morphium.createQueryFor(ComplexObject.class).f("ein_text").eq("A test");
o = q.get();
assert (o.getLastAccess() != 0) : "Last access not set!";
o = new ComplexObject();
o.setEinText("A test2");
o.setTrans("Tansient");
o.setNullValue(18);
List<ComplexObject> lst = morphium.readAll(ComplexObject.class);
for (ComplexObject co : lst) {
assert (co.getChanged() != 0) : "Last Access not set!";
}
}
@Test
public void testCopmplexQuery() {
for (int i = 1; i <= 100; i++) {
UncachedObject o = new UncachedObject();
o.setCounter(i);
o.setValue("Uncached " + i);
morphium.store(o);
}
Query<UncachedObject> q = morphium.createQueryFor(UncachedObject.class);
q.f("counter").lt(50).or(q.q().f("counter").eq(10), q.q().f("value").eq("Uncached 15"));
List<UncachedObject> lst = q.asList();
assert (lst.size() == 2) : "List size wrong: " + lst.size();
for (UncachedObject o : lst) {
assert (o.getCounter() < 50 && (o.getCounter() == 10 || o.getCounter() == 15)) : "Counter wrong: " + o.getCounter();
}
q = morphium.createQueryFor(UncachedObject.class);
q.f("counter").lt(50).or(q.q().f("counter").eq(10), q.q().f("value").eq("Uncached 15"), q.q().f("counter").eq(52));
lst = q.asList();
assert (lst.size() == 2) : "List size wrong: " + lst.size();
for (UncachedObject o : lst) {
assert (o.getCounter() < 50 && (o.getCounter() == 10 || o.getCounter() == 15)) : "Counter wrong: " + o.getCounter();
}
q = morphium.createQueryFor(UncachedObject.class);
q.f("counter").lt(50).f("counter").gt(10).or(q.q().f("counter").eq(22), q.q().f("value").eq("Uncached 15"), q.q().f("counter").gte(70));
lst = q.asList();
assert (lst.size() == 2) : "List size wrong: " + lst.size();
for (UncachedObject o : lst) {
assert (o.getCounter() < 50 && o.getCounter() > 10 && (o.getCounter() == 22 || o.getCounter() == 15)) : "Counter wrong: " + o.getCounter();
}
}
@Test
public void testNorQuery() throws Exception {
for (int i = 1; i <= 100; i++) {
UncachedObject o = new UncachedObject();
o.setCounter(i);
o.setValue("Uncached " + i);
morphium.store(o);
}
Thread.sleep(500);
Query<UncachedObject> q = morphium.createQueryFor(UncachedObject.class);
q.nor(q.q().f("counter").lt(90), q.q().f("counter").gt(95));
log.info("Query: " + q.toQueryObject().toString());
List<UncachedObject> lst = q.asList();
assert (lst.size() == 6) : "List size wrong: " + lst.size();
for (UncachedObject o : lst) {
assert (!(o.getCounter() < 90 || o.getCounter() > 95)) : "Counter wrong: " + o.getCounter();
}
}
@Test
public void complexQuery() {
for (int i = 1; i <= 100; i++) {
UncachedObject o = new UncachedObject();
o.setCounter(i);
o.setValue("Uncached " + i);
morphium.store(o);
}
Map<String, Object> query = new HashMap<>();
query.put("counter", Utils.getMap("$lt", 10));
Query<UncachedObject> q = morphium.createQueryFor(UncachedObject.class);
List<UncachedObject> lst = q.complexQuery(query);
assert (lst != null && !lst.isEmpty()) : "Nothing found?";
for (UncachedObject o : lst) {
assert (o.getCounter() < 10) : "Wrong counter: " + o.getCounter();
}
}
@Test
public void referenceQuery() throws Exception {
UncachedObject o = new UncachedObject();
o.setCounter(15);
o.setValue("Uncached " + 15);
morphium.store(o);
ComplexObject co = new ComplexObject();
co.setEinText("Text");
co.setRef(o);
co.setTrans("trans");
morphium.store(co);
Query<ComplexObject> qc = morphium.createQueryFor(ComplexObject.class);
qc.f("ref").eq(o);
ComplexObject fnd = qc.get();
assert (fnd != null) : "not found?!?!";
assert (fnd.getEinText().equals(co.getEinText())) : "Text different?";
assert (fnd.getRef().getCounter() == co.getRef().getCounter()) : "Reference broken?";
}
@Test
public void searchForSubObj() throws Exception {
UncachedObject o = new UncachedObject();
o.setCounter(15);
o.setValue("Uncached " + 15);
morphium.store(o);
ComplexObject co = new ComplexObject();
co.setEinText("Text");
co.setRef(o);
co.setTrans("trans");
EmbeddedObject eo = new EmbeddedObject();
eo.setName("embedded1");
eo.setValue("154");
co.setEmbed(eo);
morphium.store(co);
waitForWrites();
Query<ComplexObject> qc = morphium.createQueryFor(ComplexObject.class);
co = qc.f("embed.name").eq("embedded1").get();
assert (co != null);
assert (co.getEmbed() != null);
assert (co.getEmbed().getName().equals("embedded1"));
assert (co.getEinText().equals("Text"));
}
}
| [
"sb@caluga.de"
] | sb@caluga.de |
998f870c669f76ce2a1e748f98d3dee618f1497f | d3b5531d254999ab09c1c14f12c8844bcbdf3da0 | /src/main/java/org/uma/bdbio2018/benchmark/DBBenchmark.java | c45fd7d00ead2fbeca1ef9c5b2e6e7aa6e9d73ca | [] | no_license | elenamesga/BDFinal | 502657b5d0e8ca189faea9d80807bab7c15978f8 | 241fee6aa676b695dd3515146f910d4e4933dc9e | refs/heads/master | 2020-03-18T20:03:46.056146 | 2019-03-11T19:45:07 | 2019-03-11T19:45:07 | 135,193,620 | 0 | 0 | null | 2018-06-05T16:59:09 | 2018-05-28T18:01:24 | Java | UTF-8 | Java | false | false | 1,560 | java | package org.uma.bdbio2018.benchmark;
import org.uma.bdbio2018.benchmark.contracts.DBConnection;
/**
* Represents a generic database benchmark.
*
* @author Miguel González <sosa@uma.es>
*/
public class DBBenchmark {
private long executingStatementDuration;
private DBBenchmark(Executor executor) {
this.executingStatementDuration = executor.executingStatementDuration;
}
public long getExecutingStatementDuration() {
return this.executingStatementDuration;
}
/**
* Orchestrator of the benchmark. Wraps the query execution in order to obtain information of
* it.
*/
public static class Executor {
DBConnection connection;
long executingStatementDuration;
public Executor(DBConnection connection) {
this.connection = connection;
}
/**
* Executes the provided query computing its duration.
*
* @param query String-represented query statement.
* @return DBBenchmark object with the information of the query execution.
* @throws BenchmarkException when query execution fails.
*/
public DBBenchmark executeQuery(String query) throws BenchmarkException {
long beforeExec = System.currentTimeMillis();
connection.executeQuery(query);
long afterExec = System.currentTimeMillis();
this.executingStatementDuration = afterExec - beforeExec;
this.connection.close();
return new DBBenchmark(this);
}
}
}
| [
"sosa@uma.es"
] | sosa@uma.es |
c045b11e64c32503ac1dad15230abad25eac8051 | f1a960e0a62e8188a05fb8e50751a11d19133e4a | /crux-dev/src/main/java/org/cruxframework/crux/core/rebind/screen/widget/creator/direction/DirectionEstimator.java | aa7b4ed27a94a0b2917289341da6908927f62fe5 | [] | no_license | CruxFramework/crux | 4fe5b6dbf9ee02c86ca84339e4489c197b84c0ab | b11bdc7c8ef6a70c62aa7460453109d853134b18 | refs/heads/master | 2022-12-23T23:31:52.415055 | 2016-08-05T19:10:55 | 2016-08-05T19:10:55 | 33,684,032 | 27 | 13 | null | 2022-12-13T19:14:41 | 2015-04-09T17:59:03 | Java | UTF-8 | Java | false | false | 835 | java | /*
* Copyright 2011 cruxframework.org.
*
* 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 org.cruxframework.crux.core.rebind.screen.widget.creator.direction;
/**
* @author Thiago da Rosa de Bustamante
*
*/
public enum DirectionEstimator
{
anyRtl, firstStrong, wordCount, defaultAlign
}
| [
"thiago@cruxframework.org"
] | thiago@cruxframework.org |
003414de0adfc9be8661586749caf698b153a447 | 5695f15f8167a03c99ffc0a62e79279a0a84286f | /src/ml/data/features/Value.java | f241b2823d40f3dcbe1a632f94e99398753c9fff | [] | no_license | sekcheong/dt-learn | 5569fbf4229e55000bead0eaf64c7527567269d7 | 6309cb95d7d84f309d0a27d676f96c08abbea12a | refs/heads/master | 2021-01-16T19:35:24.410579 | 2017-02-19T17:33:27 | 2017-02-19T17:33:27 | 17,464,527 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 836 | java | package ml.data.features;
public abstract class Value implements Comparable<Value> {
private Feature _feature;
public abstract boolean isMissing();
public abstract Object value();
public Feature feature() {
return _feature;
}
protected void setFeature(Feature feature) {
_feature = feature;
}
public Feature.DataType dataType() {
return _feature.dataType();
}
@Override
public int hashCode() {
return this.value().hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Value other = (Value) obj;
if (this.feature().dataType()!=other.feature().dataType()) return false;
return this.compareTo(other)==0;
}
public abstract int toInt();
public abstract double toReal();
} | [
"scheong@gmail.com"
] | scheong@gmail.com |
4ecadd802d50bed7f4dd43163eb6745980631cdb | e03a2896dbc5d6d0490045ce37df4e44c97a3e85 | /itt_practice/itt_l25_thread_pool/EngineTask.java | 1d385553aca678ae4349c7c72e11f143d2218769 | [] | no_license | stanislav-ivanov5/itt | 18a0e1342e2bf2467cce4bab3c9138849fbbe457 | 65968814c9dc90bb62a25224ecd4bfaae5cd2ca6 | refs/heads/master | 2021-01-10T03:26:05.832246 | 2016-04-12T10:09:33 | 2016-04-12T10:09:33 | 47,538,474 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 396 | java | package lesson25_thread_pool;
public class EngineTask implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " start producing engine ");
try {
Thread.sleep(7000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " engine ready ");
}
}
| [
"siivanov@mail.bg"
] | siivanov@mail.bg |
4f72c2a6d27a706155c7274888d3cecd4df057e0 | f4b7dfcd383d0a506155d7d8c6dbada05dd0976d | /app/src/main/java/org/aetienne/app/viewmodel/ListSimpleAdapter.java | aca65626786fa008fd4b39ba38a1159695d723e0 | [] | no_license | AdrienEtienne/HostCardEmulationTester | 239ce999d86ddb1d80a33b6ac3b9b7db367e20b6 | 9b96a35d41b6fac961594fe83ed88bdd9355c59f | refs/heads/master | 2021-01-13T00:45:12.516388 | 2015-09-26T18:32:53 | 2015-09-26T18:32:53 | 43,169,161 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,971 | java | package org.aetienne.app.viewmodel;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import android.app.Activity;
import org.aetienne.app.R;
import java.util.List;
public class ListSimpleAdapter extends ArrayAdapter<ListItemSimpleAbstract>{
private Context context;
public ListSimpleAdapter(Context context, List items) {
super(context, android.R.layout.simple_list_item_1, items);
this.context = context;
}
/**
* Holder for the list items.
*/
private class ViewHolder{
TextView titleText;
TextView subtitleText;
}
/**
*
* @param position
* @param convertView
* @param parent
* @return
*/
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
ListItemSimpleAbstract item = (ListItemSimpleAbstract)getItem(position);
View viewToUse = null;
// This block exists to inflate the settings list item conditionally based on whether
// we want to support a grid or list view.
LayoutInflater mInflater = (LayoutInflater) context
.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
if (convertView == null) {
viewToUse = mInflater.inflate(R.layout.list_item_simple, null);
holder = new ViewHolder();
holder.titleText = (TextView)viewToUse.findViewById(R.id.titleTextView);
holder.subtitleText = (TextView)viewToUse.findViewById(R.id.subtitleTextView);
viewToUse.setTag(holder);
} else {
viewToUse = convertView;
holder = (ViewHolder) viewToUse.getTag();
}
holder.titleText.setText(item.getItemTitle());
holder.subtitleText.setText(item.getItemSubtitle());
return viewToUse;
}
}
| [
"a.etienne92@gmail.com"
] | a.etienne92@gmail.com |
4a4687d15a74fc5cf0ba233dad1c0a25d1a80316 | 14939bab24058b4f6fe0f34b3a910a1c344358f9 | /app/src/main/java/com/zmr/xuxiaoxing/ui/login/activity/ForgotPwdActivity.java | 9146c7fa143066e7cc51b91ad42b3d1572666bdc | [] | no_license | xx753940262/xuxiaoxing | f3d426937ae73d92c8fe5b5de5eb676c8d9a84a8 | 37a188716a3b67837aae8c1401414c4ef2cfeda7 | refs/heads/master | 2020-05-21T19:55:46.601762 | 2017-05-06T08:52:37 | 2017-05-06T08:52:37 | 65,193,229 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,214 | java | package com.zmr.xuxiaoxing.ui.login.activity;
import android.content.Context;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import com.xiaoxing.common.base.BaseApi;
import com.xiaoxing.common.base.BaseConstant;
import com.xiaoxing.common.util.AbStrUtil;
import com.xiaoxing.common.util.ToastUtil;
import com.xiaoxing.common.view.clear_edit_text.ClearEditText;
import com.zmr.xuxiaoxing.R;
import com.zmr.xuxiaoxing.base.AppBaseActivity;
import com.zmr.xuxiaoxing.ui.login.model.SendSMS;
import org.json.JSONException;
import org.json.JSONObject;
import butterknife.BindView;
import butterknife.OnClick;
/**
* 描述：忘记密码
* 作者：xiaoxing on 17/4/7 15:07
* 邮箱：2235445233@qq.com
*/
public class ForgotPwdActivity extends AppBaseActivity {
@BindView(R.id.cet_tel)
ClearEditText mCetTel;
@BindView(R.id.btn_next_step)
Button mBtnNextStep;
private String mTel;
@Override
public int bindLayout() {
return R.layout.activity_forgot_pwd;
}
@Override
public void initView(View view) {
super.initView(view);
setHeaderTitle(R.string.find_pwd);
}
@OnClick(R.id.btn_next_step)
public void onClick() {
next();
}
@Override
public void doBusiness(Context mContext) {
super.doBusiness(mContext);
}
@Override
public void onMessageResponse(String url, JSONObject jo) throws JSONException {
httpResultSendCheckCode(url, jo);
}
/**
* 发送验证码
*
* @param url
* @param jo
*/
private void httpResultSendCheckCode(String url, JSONObject jo) {
if (url.equals(BaseConstant.SENE_CHECK_CODE) && jo != null) {
try {
SendSMS sendSMS = new SendSMS(jo.toString());
if (sendSMS != null) {
if (sendSMS.getCode().equals("200")) {
ToastUtil.showMessage(this, "验证码发送成功");
Bundle bundle = new Bundle();
bundle.putString("tel", mTel);
bundle.putString("type", "forgot");
startBundleActivity(bundle, SetPwdActivity.class);
} else {
ToastUtil.showMessage(this, sendSMS.getMsg());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 下一步
*/
private void next() {
if (checkTel()) {
sendCheckCode();
}
}
/**
* 发送验证码
*/
private void sendCheckCode() {
showGifdialog();
BaseApi.sendCheckCode(this, mTel);
}
/**
* 验证手机号
*
* @return
*/
private boolean checkTel() {
mTel = getEidtTextValue(mCetTel);
if (AbStrUtil.isEmpty(mTel)) {
ToastUtil.showMessage(this, "手机号不能为空");
return false;
} else if (!AbStrUtil.isMobileNo(mTel)) {
ToastUtil.showMessage(this, "手机号格式错误");
return false;
}
return true;
}
}
| [
"753940262@qq.com"
] | 753940262@qq.com |
b0b28f77d06f5d2cdab48ec2449b5016ccfbcd83 | 53c590c56d93f07d0fbe3edb236395d73145025c | /ots-web/src/main/java/com/mk/ots/member/service/IUnionidLogService.java | 76d68d103bc6a874cca38fb96e1249b62fb5fcb9 | [] | no_license | liuwenqi9/ots | 7ab5bb694464c0c18dbcbbf33a32b4695d2c938d | 38ba402c10855b58dc368d6c5590da92396dadf7 | refs/heads/master | 2020-04-30T00:13:34.803602 | 2016-03-04T08:35:41 | 2016-03-04T08:35:41 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 255 | java | package com.mk.ots.member.service;
import com.mk.ots.member.model.UUnionidLog;
import java.util.List;
/**
*
*/
public interface IUnionidLogService {
public List<UUnionidLog> queryByUnionid(String unionid);
public int saveLog(UUnionidLog log);
}
| [
"jie.huang@imike.com"
] | jie.huang@imike.com |
eba2bb25387b8722e133517db1565c0d6e052f5d | d4d8c29716add66b88460bbbcb1c5792a9f7c0a0 | /src/main/java/cs544/aspect/BankSystemAdvice.java | b62a4fb357478ffce8f16d6355172824a709dd64 | [] | no_license | brreex/AOP2 | d43da94de9d8375b1622076bc1290c191847abd9 | 972fa6c4c35468d6b3e567a712679baf09b95aa4 | refs/heads/master | 2021-01-25T08:19:43.591562 | 2017-06-08T13:54:17 | 2017-06-08T13:54:17 | 93,755,317 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,502 | java | package cs544.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.util.StopWatch;
@Aspect
public class BankSystemAdvice {
@After("execution(* cs544.bank.dao.*.*(..))")
public void logDao(JoinPoint joinpoint){
System.out.println("Logger Method called");
System.out.println("Method Name= "+ joinpoint.getSignature().getName());
}
@Around("execution(* cs544.bank.service.*.*(..))")
public Object methodTimer(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
StopWatch stopWatch = new StopWatch();
stopWatch.start(proceedingJoinPoint.getSignature().getName());
Object obj = proceedingJoinPoint.proceed();
stopWatch.stop();
long timeTaken = stopWatch.getLastTaskTimeMillis();
System.out.println("Method "+ proceedingJoinPoint.getSignature().getName()+" In service Took " +timeTaken +" Second To Finish");
return obj;
}
@After("execution(* cs544.bank.logging.*.*(..))")
public void traceLogger(JoinPoint joinPoint){
System.out.println("Tracing Method "+ joinPoint.getSignature().getName() +" in logging package");
}
@After("execution(* cs544.bank.jms.*.*(..))")
public void logJMSMessage(JoinPoint joinPoint){
System.out.println("Tracing method "+joinPoint.getSignature().getName()+ " in JMS package");
}
}
| [
"berhanuasa@gmail.com"
] | berhanuasa@gmail.com |
d6a746a3b06960976dc0532d6c71dabb26c7cf44 | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/2/2_abae1b3f1aef8dac1a31448842930fa80d0fedb7/Main/2_abae1b3f1aef8dac1a31448842930fa80d0fedb7_Main_s.java | 8e3545dfb36f1bb1d69ae74863cf17caf83bfe27 | [] | no_license | zhongxingyu/Seer | 48e7e5197624d7afa94d23f849f8ea2075bcaec0 | c11a3109fdfca9be337e509ecb2c085b60076213 | refs/heads/master | 2023-07-06T12:48:55.516692 | 2023-06-22T07:55:56 | 2023-06-22T07:55:56 | 259,613,157 | 6 | 2 | null | 2023-06-22T07:55:57 | 2020-04-28T11:07:49 | null | UTF-8 | Java | false | false | 2,516 | java | /*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
package core;
import autonomous.Autonomous;
import utilities.Robot;
import utilities.Vars;
import utilities.MyJoystick;
import edu.wpi.first.wpilibj.IterativeRobot;
/**
* The VM is configured to automatically run this class, and to call the
* functions corresponding to each mode, as described in the IterativeRobot
* documentation. If you change the name of this class or the package after
* creating this project, you must also update the manifest file in the resource
* directory.
*/
public class Main extends IterativeRobot
{
final String sCodeVersion = "Welcome to Bubblefish 2.2 Series !";
MyJoystick ps3Joy = new MyJoystick(1, Vars.iPs3Buttons);
Robot bot = new Robot(ps3Joy);
Compressor compressor = new Compressor();
Autonomous autonomous = new Autonomous(ps3Joy, bot);
/*
* This function is run when the robot is first started up and should be
* used for any initialization code.
*/
public void robotInit()
{
Vars.fnPutDashBoardStringBox(Vars.skCodeVersion, sCodeVersion);
}
// This function is called when we disable the robot.
public void disabledInit()
{
// Resets the replay to false if it was true before
autonomous.resetAutonomous();
}
public void disabledPeriodic()
{
compressor.run();
}
/* Called once in autonomous, tells autonomous which file to play based on
* the value of "iFileType"
*/
public void autonomousInit()
{
autonomous.setFileBasedOnDriverInput();
}
// This function is called periodically during autonomous
public void autonomousPeriodic()
{
autonomous.replay();
}
// This function is called periodically during operator control
public void teleopPeriodic()
{
bot.run();
compressor.run();
autonomous.run();
}
}
| [
"yuzhongxing88@gmail.com"
] | yuzhongxing88@gmail.com |
1398367dbfeebc3428ea413b6bbc9ab1533a1b44 | 0c5065e13ab3a11826a5e08f097ecfad653503d9 | /WEB-INF/classes/com/avekshaa/cis/login/UserMasterDAO.java | 8d20a6a7f3329071f943ce0a44a45dfffbc4991c | [] | no_license | gaurav2naik/newcis2 | bb845dd452d418e9b578abac5be417fd067bb414 | af384963a62d59c0dd7b6229e0ae57de72c44091 | refs/heads/master | 2021-01-10T11:13:06.302850 | 2016-01-20T05:45:17 | 2016-01-20T05:45:17 | 49,926,763 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,954 | java | package com.avekshaa.cis.login;
import java.sql.Statement;
import org.apache.log4j.Logger;
import com.avekshaa.cis.database.CommonDB;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.WriteResult;
public class UserMasterDAO {
static final Logger logger = Logger.getRootLogger();
public static DB m;
static {
m = CommonDB.getBankConnection();
}
public static UserMasterBean createUser(UserMasterBean bean) {
String username = bean.getUsername();
String password = bean.getPassword();
String userid = bean.getUserId();
DBCursor dbCursor = null;
try {
DBCollection User = m.getCollection("UserAuth");
BasicDBObject whereQuery = new BasicDBObject();
whereQuery.put("UserName", username);
dbCursor = User.find(whereQuery);
boolean isUserAlreadyExist = dbCursor.hasNext();
// if user does not exist set the isValid variable to false
if (!isUserAlreadyExist) {
// ////System.out.println("Add User");
BasicDBObject addUser = new BasicDBObject();
addUser.put("UserId", userid);
addUser.put("UserName", username);
addUser.put("Password", password);
User.insert(addUser);
bean.setValid(true);
}
// if user exists set the isValid variable to true
else if (isUserAlreadyExist) {
// ////System.out.println("User Already Exist");
bean.setValid(false);
}
}
catch (Exception ex) {
// //System.out.println("Log In failed: An Exception has occurred! "+
// ex);
logger.error("Unexpected error", ex);
}
finally {
dbCursor.close();
}
return bean;
}
public static UserMasterBean createPremiumUser(UserMasterBean bean) {
String Puser = bean.getPremiumuser();
DBCursor dbCursor = null;
try {
DBCollection PUser = m.getCollection("PremiumUser");
BasicDBObject whereQuery = new BasicDBObject();
whereQuery.put("PremiumUserName", Puser);
dbCursor = PUser.find(whereQuery);
boolean isUserAlreadyExist = dbCursor.hasNext();
// if user does not exist set the isValid variable to false
if (!isUserAlreadyExist) {
// ////System.out.println("Add User");
BasicDBObject addPUser = new BasicDBObject();
addPUser.put("PremiumUserName", Puser);
PUser.insert(addPUser);
bean.setValid(true);
}
// if user exists set the isValid variable to true
else if (isUserAlreadyExist) {
// ////System.out.println("User Already Exist");
bean.setValid(false);
}
}
catch (Exception ex) {
// //System.out.println("Log In failed: An Exception has occurred! "+
// ex);
logger.error("Unexpected error", ex);
}
finally {
dbCursor.close();
}
return bean;
}
// Delete Premium user
public static UserMasterBean deletePremiumUser(UserMasterBean bean) {
String pmUser = bean.getPremiumuser().trim();
System.out.println("inside delete UMD" + pmUser);
DBCursor dbCursor = null;
try {
DBCollection premiumUser = m.getCollection("PremiumUser");
System.out.println("Collection" + premiumUser);
BasicDBObject query = new BasicDBObject("PremiumUserName", pmUser);
// whereQuery.put("PremiumUserName", Puser);
dbCursor = premiumUser.find(query);
System.out.println("UMD count:" + premiumUser.find(query).count());
boolean isUserExist = dbCursor.hasNext();
System.out.println("inside delete UMD :" + isUserExist);
// if user does exist set the isValid variable to true
if (isUserExist) {
// ////System.out.println("Add User");
BasicDBObject deletePUser = new BasicDBObject();
deletePUser.put("PremiumUserName", pmUser);
WriteResult status = premiumUser.remove(deletePUser);
System.out.println("Delete user status :" + status);
bean.setValid(true);
}
// if user does not exist set the isValid variable to false
else if (!isUserExist) {
// ////System.out.println("User Already Exist");
bean.setValid(false);
}
}
catch (Exception ex) {
// //System.out.println("Log In failed: An Exception has occurred! "+
// ex);
logger.error("Unexpected error", ex);
}
finally {
dbCursor.close();
}
return bean;
}
public static String disableUser(String deleteUser) {
Statement stmt = null;
String userDeleted = "";
try {
// //System.out.println("In UserMasterDAO");
// //System.out.println("Delete UserName: " + deleteUser);
DBCollection dbCollection = m.getCollection("UserAuth");
BasicDBObject document = new BasicDBObject();
document.put("UserName", deleteUser);
// DBCursor dbCursor = dbCollection.find(document);
dbCollection.remove(document);
userDeleted = "S";
// //System.out.println("User Deleted Successfully...");
/*
* while(dbCursor.hasNext()) { dbCollection.remove(document);
* //bean.setValid(true);
* ////System.out.println("User Deleted Successfully..."); }
*/
}
catch (Exception ex) {
userDeleted = "F";
// //System.out.println("Log In failed: An Exception has occurred! "+
// ex);
logger.error("Unexpected error", ex);
}
finally {
}
return userDeleted;
}
public static UserMasterBean modifyUser(UserMasterBean bean) {
String userName = bean.getUsername();
String email = bean.getEmail();
String mobile = bean.getMobile();
DB db = CommonDB.getConnection();
DBCollection dbCollection = db.getCollection("UserAuth");
BasicDBObject updateColumns = new BasicDBObject();
BasicDBObject updateQuery = new BasicDBObject();
// updateColumns.put("UserName", userName);
updateColumns.put("Email", email);
updateColumns.put("Mobile", mobile);
updateQuery.put("$set", updateColumns);
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.append("UserName", userName);
dbCollection.updateMulti(searchQuery, updateQuery);
/*
* AndroidAverageCalculation.setMail(); WebResponseAvg.setMail();
*/
// System.out.println(userName + " "+email + " "+mobile );
return bean;
}
} | [
"gaurav.loveboy2000@gmail.com"
] | gaurav.loveboy2000@gmail.com |
9e7cde9898db478c391b6b9c36c02fd64619b6eb | 14746c4b8511abe301fd470a152de627327fe720 | /soroush-android-1.10.0_source_from_JADX/mobi/mmdt/ott/view/tools/C4478a.java | 772214947f08e21afa9a3e689b9095d0201cfbce | [] | no_license | maasalan/soroush-messenger-apis | 3005c4a43123c6543dbcca3dd9084f95e934a6f4 | 29867bf53a113a30b1aa36719b1c7899b991d0a8 | refs/heads/master | 2020-03-21T21:23:20.693794 | 2018-06-28T19:57:01 | 2018-06-28T19:57:01 | 139,060,676 | 3 | 2 | null | null | null | null | UTF-8 | Java | false | false | 19,609 | java | package mobi.mmdt.ott.view.tools;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import java.util.ArrayList;
import mobi.mmdt.ott.MyApplication;
import mobi.mmdt.ott.R;
import mobi.mmdt.ott.logic.location.ChannelsMapsActivity;
import mobi.mmdt.ott.logic.location.MapsActivity;
import mobi.mmdt.ott.provider.p384f.C2973m;
import mobi.mmdt.ott.view.autoupdate.UserNameUpdateActivity;
import mobi.mmdt.ott.view.call.CallActivity;
import mobi.mmdt.ott.view.channel.addmembers.ManageFollowersActivity;
import mobi.mmdt.ott.view.components.mediaviewer.ImageViewerActivity;
import mobi.mmdt.ott.view.components.mediaviewer.MediaViewerActivity;
import mobi.mmdt.ott.view.components.report.ReportActivity;
import mobi.mmdt.ott.view.contact.contactprofileinfo.ContactProfileInfoActivity;
import mobi.mmdt.ott.view.contact.contactprofileinfo.ContactProfileInfoActivityThemeDialog;
import mobi.mmdt.ott.view.conversation.C3290a;
import mobi.mmdt.ott.view.conversation.activities.C3383b;
import mobi.mmdt.ott.view.conversation.activities.ConversationActivity;
import mobi.mmdt.ott.view.conversation.createpayment.CreatePaymentActivity;
import mobi.mmdt.ott.view.conversation.createpoll.CreatePollActivity;
import mobi.mmdt.ott.view.conversation.forward.ForwardActivity;
import mobi.mmdt.ott.view.conversation.groupinfo.invitelink.CreateInviteLinkActivity;
import mobi.mmdt.ott.view.conversation.sharedmediaviewer.SharedMediaViewerActivity;
import mobi.mmdt.ott.view.main.ContactsActivity;
import mobi.mmdt.ott.view.newdesign.mainpage.MainActivity;
import mobi.mmdt.ott.view.passcode.PassCodeActivity;
import mobi.mmdt.ott.view.search.SearchActivity;
import mobi.mmdt.ott.view.settings.forceupdate.ForceUpdateActivity;
import mobi.mmdt.ott.view.settings.mainsettings.localpasscode.LocalPassCodeSettingsListActivity;
import mobi.mmdt.ott.view.settings.mainsettings.profileinfo.ProfileInfoSettingsActivity;
import mobi.mmdt.ott.view.stickermarket.StickerMarketActivity;
import mobi.mmdt.ott.view.stickermarket.stickersettings.StickerSettingsActivity;
import mobi.mmdt.ott.view.stickermarket.stickersettings.StickerSettingsActivityThemeDialog;
import mobi.mmdt.ott.view.vas.owghat.OwghatActivity;
import mobi.mmdt.ott.view.vas.owghat.setting.OwghatSettingActivity;
import mobi.mmdt.ott.view.vas.payservices.bill.view.BillPaymentActivity;
import mobi.mmdt.ott.view.vas.payservices.charge.view.ChargeActivity;
import mobi.mmdt.ott.view.vas.weather.WeatherActivity;
public final class C4478a {
public static PendingIntent m8136a(int i, String str, C3290a c3290a) {
Intent intent = new Intent(MyApplication.m12952b(), CallActivity.class);
intent.putExtra("key_contact_user_id_string", str);
intent.putExtra("key_start_mode", c3290a.ordinal());
return PendingIntent.getActivity(MyApplication.m12952b(), i, intent, 134217728);
}
public static void m8137a() {
Intent intent = new Intent(MyApplication.m12952b(), ForceUpdateActivity.class);
intent.setFlags(268435456);
MyApplication.m12952b().startActivity(intent);
}
public static void m8138a(Activity activity) {
Intent intent = new Intent(activity, ProfileInfoSettingsActivity.class);
intent.putExtra("KEY_ENTER_FOR_SETTING", true);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8139a(Activity activity, double d, double d2) {
Intent intent = new Intent(activity, ChannelsMapsActivity.class);
intent.putExtra("KEY_LATITUDE", d);
intent.putExtra("KEY_LONGITUDE", d2);
activity.startActivityForResult(intent, 100);
}
public static void m8140a(Activity activity, double d, double d2, boolean z) {
Intent intent = new Intent(activity, MapsActivity.class);
intent.putExtra("KEY_LATITUDE", d);
intent.putExtra("KEY_LONGITUDE", d2);
intent.putExtra("KEY_ENTER_FROM_CHANNEL_INFO", z);
activity.startActivity(intent);
}
public static void m8141a(Activity activity, Intent intent) {
if (activity != null) {
Intent intent2 = new Intent(activity, PassCodeActivity.class);
if (intent.getExtras() != null) {
intent2.putExtras(intent.getExtras());
}
if (intent.getData() != null) {
intent2.setData(intent.getData());
}
if (intent.getAction() != null) {
intent2.setAction(intent.getAction());
}
if (intent.getType() != null) {
intent2.setType(intent.getType());
}
intent2.setFlags(268435456);
intent2.putExtra("FROM_SETTING", false);
intent2.putExtra("KEY_ENTER_WITH_TIMER", false);
intent2.putExtra("KEY_ENTER_FROM_NOTIFICATION", true);
activity.startActivity(intent2);
}
}
public static void m8142a(Activity activity, Class<?> cls) {
activity.startActivity(new Intent(activity, cls));
C4478a.m8165c(activity, true);
}
public static void m8143a(Activity activity, String str) {
Intent intent = new Intent(activity, ManageFollowersActivity.class);
intent.putExtra("KEY_CHANNEL_ID", str);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8144a(Activity activity, String str, String str2, String str3) {
C4478a.m8146a(activity, str, str2, str3, false);
}
public static void m8145a(Activity activity, String str, String str2, String str3, String str4) {
Intent intent = new Intent(activity, CreateInviteLinkActivity.class);
intent.putExtra("KEY_GROUP_ID", str);
intent.putExtra("KEY_GROUP_NAME", str2);
intent.putExtra("KEY_GROUP_IMAGE", str3);
intent.putExtra("KEY_GROUP_MEMBER_COUNT", str4);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8146a(Activity activity, String str, String str2, String str3, boolean z) {
Intent intent = new Intent(activity, ConversationActivity.class);
intent.putExtra("KEY_START_KIND", C3383b.f10381c - 1);
intent.putExtra("KEY_LAST_POSITION", str3);
intent.putExtra("KEY_PARTY", str);
intent.putExtra("isOpenByLink", z);
if (str2 != null) {
intent.putExtra("key_searched_message_id", str2);
}
if (activity != null) {
activity.startActivity(intent);
C4478a.m8161b(activity, false);
C4478a.m8165c(activity, true);
}
}
public static void m8147a(Activity activity, String str, String str2, C2973m c2973m) {
Intent intent = new Intent(activity, SharedMediaViewerActivity.class);
intent.putExtra("KEY_PEER_PARTY", str);
intent.putExtra("KEY_TITLE_TEXT", str2);
if (c2973m != null) {
intent.putExtra("KEY_GROUP_TYPE", c2973m.ordinal());
}
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8148a(Activity activity, String str, String str2, C2973m c2973m, String str3) {
Intent intent = new Intent(activity, MediaViewerActivity.class);
intent.putExtra("KEY_PEER_PARTY", str2);
intent.putExtra("KEY_TITLE", str3);
if (c2973m != null) {
intent.putExtra("KEY_GROUP_TYPE", c2973m.ordinal());
}
intent.putExtra("KEY_MEDIA_PATH", str);
if (activity != null) {
activity.startActivityForResult(intent, 27);
C4478a.m8165c(activity, true);
}
}
public static void m8149a(Activity activity, String str, boolean z) {
if (activity.getResources().getBoolean(R.bool.xlarge)) {
Intent intent = new Intent(activity, ContactProfileInfoActivityThemeDialog.class);
intent.putExtra("KEY_CONTACT_USER_ID_STRING", str);
intent.putExtra("KEY_SHOW_LOCAL_INFO_BOOLEAN", z);
activity.startActivity(intent);
activity.overridePendingTransition(R.anim.anim_fade_in_activity_theme_dialog, R.anim.anim_fade_out_activity_theme_dialog);
return;
}
intent = new Intent(activity, ContactProfileInfoActivity.class);
intent.putExtra("KEY_CONTACT_USER_ID_STRING", str);
intent.putExtra("KEY_SHOW_LOCAL_INFO_BOOLEAN", z);
activity.startActivity(intent);
C4478a.m8161b(activity, false);
C4478a.m8165c(activity, true);
}
public static void m8150a(Activity activity, String str, boolean z, String str2, String str3) {
Intent intent = new Intent(activity, ConversationActivity.class);
intent.putExtra("KEY_LAST_POSITION", str3);
intent.putExtra("KEY_START_KIND", C3383b.f10379a - 1);
intent.putExtra("KEY_PARTY", str);
if (!(str2 == null || str2.isEmpty())) {
intent.putExtra("key_searched_message_id", str2);
}
if (activity != null) {
activity.startActivity(intent);
C4478a.m8161b(activity, z);
C4478a.m8165c(activity, true);
}
}
public static void m8151a(Activity activity, ArrayList<String> arrayList, String str, int i, boolean z) {
Intent intent = new Intent(activity, ForwardActivity.class);
intent.putStringArrayListExtra("key_to_forward_message_id", arrayList);
intent.putExtra("key_is_forward_mode", true);
intent.putExtra("KEY_PEER_PARTY", str);
intent.putExtra("KEY_GROUP_TYPE", i);
if (activity != null) {
activity.startActivityForResult(intent, 19);
C4478a.m8161b(activity, z);
C4478a.m8165c(activity, true);
}
}
public static void m8152a(Activity activity, C2973m c2973m, String str, String str2) {
Intent intent = new Intent(activity, ReportActivity.class);
intent.putExtra("KEY_PEER_PARTY", str);
intent.putExtra("KEY_NAME_CONVERSATION", str2);
intent.putExtra("KEY_GROUP_TYPE", c2973m.ordinal());
if (activity != null) {
activity.startActivityForResult(intent, 10);
C4478a.m8165c(activity, true);
}
}
public static void m8153a(Activity activity, C4509g c4509g) {
Intent intent = new Intent(activity, ContactsActivity.class);
intent.putExtra("KEY_CONTACTS_ACTIVITY_TYPE", c4509g);
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
public static void m8154a(Activity activity, boolean z) {
Intent intent = new Intent(activity, SearchActivity.class);
intent.putExtra("full_search", z);
intent.addFlags(65536);
activity.startActivity(intent);
activity.overridePendingTransition(0, 0);
}
public static void m8155a(Activity activity, boolean z, boolean z2, boolean z3) {
Intent intent = new Intent(activity, PassCodeActivity.class);
intent.putExtra("FROM_SETTING", true);
intent.putExtra("SET_MODE", z);
intent.putExtra("KEY_IS_CHANGE_MODE", z2);
activity.startActivity(intent);
C4478a.m8165c(activity, true);
C4478a.m8161b(activity, z3);
}
public static void m8156b() {
Context b = MyApplication.m12952b();
Intent intent = new Intent(b, UserNameUpdateActivity.class);
intent.setFlags(268435456);
b.startActivity(intent);
}
public static void m8157b(Activity activity) {
if (activity.getResources().getBoolean(R.bool.xlarge)) {
activity.startActivity(new Intent(activity, StickerSettingsActivityThemeDialog.class));
activity.overridePendingTransition(R.anim.anim_fade_in_activity_theme_dialog, R.anim.anim_fade_out_activity_theme_dialog);
return;
}
activity.startActivity(new Intent(activity, StickerSettingsActivity.class));
C4478a.m8165c(activity, true);
}
public static void m8158b(android.app.Activity r2, java.lang.String r3) {
/* JADX: method processing error */
/*
Error: java.lang.NullPointerException
at jadx.core.dex.visitors.regions.ProcessTryCatchRegions.searchTryCatchDominators(ProcessTryCatchRegions.java:75)
at jadx.core.dex.visitors.regions.ProcessTryCatchRegions.process(ProcessTryCatchRegions.java:45)
at jadx.core.dex.visitors.regions.RegionMakerVisitor.postProcessRegions(RegionMakerVisitor.java:63)
at jadx.core.dex.visitors.regions.RegionMakerVisitor.visit(RegionMakerVisitor.java:58)
at jadx.core.dex.visitors.DepthTraversal.visit(DepthTraversal.java:31)
at jadx.core.dex.visitors.DepthTraversal.visit(DepthTraversal.java:17)
at jadx.core.ProcessClass.process(ProcessClass.java:37)
at jadx.core.ProcessClass.processDependencies(ProcessClass.java:59)
at jadx.core.ProcessClass.process(ProcessClass.java:42)
at jadx.api.JadxDecompiler.processClass(JadxDecompiler.java:306)
at jadx.api.JavaClass.decompile(JavaClass.java:62)
at jadx.api.JadxDecompiler$1.run(JadxDecompiler.java:199)
*/
/*
r0 = new android.content.Intent;
r1 = "android.intent.action.VIEW";
r0.<init>(r1);
r3 = android.net.Uri.parse(r3);
r1 = "video/*";
r0.setDataAndType(r3, r1);
if (r2 == 0) goto L_0x0028;
L_0x0012:
r3 = 1;
r2.startActivity(r0); Catch:{ ActivityNotFoundException -> 0x001a }
mobi.mmdt.ott.view.tools.C4478a.m8165c(r2, r3); Catch:{ ActivityNotFoundException -> 0x001a }
return;
L_0x001a:
r0 = 2131690177; // 0x7f0f02c1 float:1.900939E38 double:1.053194884E-314;
r0 = mobi.mmdt.ott.view.tools.C4522p.m8236a(r0);
r2 = android.widget.Toast.makeText(r2, r0, r3);
r2.show();
L_0x0028:
return;
*/
throw new UnsupportedOperationException("Method not decompiled: mobi.mmdt.ott.view.tools.a.b(android.app.Activity, java.lang.String):void");
}
public static void m8159b(Activity activity, String str, String str2, String str3) {
Intent intent = new Intent(activity, ConversationActivity.class);
intent.putExtra("KEY_START_KIND", C3383b.f10383e - 1);
intent.putExtra("KEY_LAST_POSITION", str3);
intent.putExtra("KEY_PARTY", str);
if (str2 != null) {
intent.putExtra("key_searched_message_id", str2);
}
if (activity != null) {
activity.startActivity(intent);
C4478a.m8161b(activity, false);
C4478a.m8165c(activity, true);
}
}
public static void m8160b(Activity activity, String str, boolean z, String str2, String str3) {
Intent intent = new Intent(activity, ConversationActivity.class);
intent.putExtra("KEY_START_KIND", C3383b.f10380b - 1);
intent.putExtra("KEY_LAST_POSITION", str3);
intent.putExtra("KEY_PARTY", str);
if (str2 != null) {
intent.putExtra("key_searched_message_id", str2);
}
if (activity != null) {
activity.startActivity(intent);
C4478a.m8161b(activity, z);
C4478a.m8165c(activity, true);
}
}
public static void m8161b(Activity activity, boolean z) {
if (z) {
activity.finish();
}
}
public static void m8162c(Activity activity) {
Intent intent = new Intent(activity, StickerMarketActivity.class);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8163c(Activity activity, String str) {
Intent intent = new Intent(activity, CallActivity.class);
intent.putExtra("key_contact_user_id_string", str);
intent.putExtra("key_start_mode", C3290a.MAKE_CALL.ordinal());
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8164c(Activity activity, String str, String str2, String str3) {
Intent intent = new Intent(activity, ImageViewerActivity.class);
intent.putExtra("KEY_MEDIA_PATH", str);
intent.putExtra("KEY_THUMBNAIL_IMAGE_PATH", str2);
intent.putExtra("KEY_TITLE", str3);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8165c(Activity activity, boolean z) {
if (z) {
activity.overridePendingTransition(R.anim.anim_slide_in_left, R.anim.anim_slide_out_left);
}
}
public static void m8166d(Activity activity) {
Intent intent = new Intent(activity, MainActivity.class);
intent.addFlags(67108864);
intent.addFlags(131072);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, false);
}
}
public static void m8167d(Activity activity, String str) {
Intent intent = new Intent(activity, CreatePollActivity.class);
intent.putExtra("key_channel_id", str);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8168e(Activity activity) {
if (activity.getResources().getBoolean(R.bool.xlarge)) {
activity.startActivity(new Intent(activity, OwghatSettingActivity.class));
activity.overridePendingTransition(R.anim.anim_fade_in_activity_theme_dialog, R.anim.anim_fade_out_activity_theme_dialog);
return;
}
activity.startActivity(new Intent(activity, OwghatSettingActivity.class));
C4478a.m8165c(activity, true);
}
public static void m8169e(Activity activity, String str) {
Intent intent = new Intent(activity, CreatePaymentActivity.class);
intent.putExtra("key_channel_id", str);
if (activity != null) {
activity.startActivity(intent);
C4478a.m8165c(activity, true);
}
}
public static void m8170f(Activity activity) {
Intent intent = new Intent(activity, OwghatActivity.class);
activity.startActivity(intent);
intent.setFlags(1073741824);
C4478a.m8165c(activity, true);
}
public static void m8171g(Activity activity) {
Intent intent = new Intent(activity, ChargeActivity.class);
activity.startActivity(intent);
intent.setFlags(1073741824);
C4478a.m8165c(activity, true);
}
public static void m8172h(Activity activity) {
Intent intent = new Intent(activity, BillPaymentActivity.class);
activity.startActivity(intent);
intent.setFlags(1073741824);
C4478a.m8165c(activity, true);
}
public static void m8173i(Activity activity) {
Intent intent = new Intent(activity, WeatherActivity.class);
activity.startActivity(intent);
intent.setFlags(1073741824);
C4478a.m8165c(activity, true);
}
public static void m8174j(Activity activity) {
Intent intent = new Intent(activity, LocalPassCodeSettingsListActivity.class);
intent.putExtra("FROM_SETTING", true);
activity.startActivity(intent);
C4478a.m8165c(activity, true);
C4478a.m8161b(activity, true);
}
}
| [
"Maasalan@riseup.net"
] | Maasalan@riseup.net |
cd61836b2c6533efef3f77822a76368fb9405038 | a7d7907d76f874958222c34251a58f9676cc2126 | /app/src/main/java/com/mobium/reference/view/ServicePointView.java | f831450afe5529973d66126a038faf3161cf6bb5 | [
"Unlicense"
] | permissive | naebomium/android | 450b29dded6c1bee112515e8cc74ddfeef2d2390 | 9e6a816a99e2fe7c7b4ad6755d945760caff854d | refs/heads/master | 2021-01-10T06:57:57.610925 | 2015-11-25T13:57:58 | 2015-11-25T13:57:58 | 46,860,560 | 5 | 1 | null | null | null | null | UTF-8 | Java | false | false | 267 | java | package com.mobium.reference.view;
/**
* on 25.07.15.
* http://mobiumapps.com/
*/
public interface ServicePointView {
void showTitle(String title);
void showPhone(String phone);
void showSubway(String subway);
void showAddress(String addtess);
}
| [
"johndoe@example.com"
] | johndoe@example.com |
f2344b124877ecef0c6e4809ce52aec63c23299b | eee4298f0dc9dc3e263542ca9db5e11cfe65788b | /app/src/main/java/com/example/projectclass/Project.java | 21baf26840d9bd2228e541ecfca9db077c163cbe | [] | no_license | rihan-odeh/ProjectClass | 0bf461848f7f0791144bdd18f188b9c70c2088a8 | 8f4d542296af89d0156d3ee946994ec8e38145e8 | refs/heads/master | 2023-06-11T21:23:42.989047 | 2021-07-09T13:57:38 | 2021-07-09T13:57:38 | 384,446,647 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 961 | java | package com.example.projectclass;
public class Project {
private String name;
private String description;
private double initialCost;
public Project(){
}
public Project(String name){
this.name = name;
}
public Project(String name, String description){
this.name=name;
this.description= description;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String elevatorPitch(){
return this.name + "(" + this.initialCost + ") : " + this.description;
}
public double getInitialCost() {
return initialCost;
}
public void setInitialCost(double initialCost) {
this.initialCost = initialCost;
}
}
| [
"73608189+rihan-odeh@users.noreply.github.com"
] | 73608189+rihan-odeh@users.noreply.github.com |
02af657b7239bf859eb00a5e72247a28150a1aca | 9688cd170101afde7dc26f6cabbb59ac8705d9da | /app/src/main/java/com/example/radugym/dataTrainingFragment.java | f66b82c2e43cf89a01452b75d892e9059d79952a | [] | no_license | radugeorge412/AndroidApp | ee1247e60fefbebafdda5d70683f644a180bc53d | 339b8ad85e0544cccfa757459cfd90594528fb6e | refs/heads/main | 2023-04-17T01:54:07.353017 | 2021-04-20T17:59:32 | 2021-04-20T17:59:32 | 359,145,548 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,082 | java | package com.example.radugym;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link dataTrainingFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class dataTrainingFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public dataTrainingFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment dataTrainingFragment.
*/
// TODO: Rename and change types and number of parameters
public static dataTrainingFragment newInstance(String param1, String param2) {
dataTrainingFragment fragment = new dataTrainingFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_training, container, false);
}
} | [
"radugeorge412@gmail.com"
] | radugeorge412@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.