blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
410
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 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
689M
⌀ | 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 131
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 32
values | content
stringlengths 3
9.45M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
313
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
24fcbbd459f61c4a50e74dc6a0be958ba4a5f7e0 | 99795b5ad3d290a9e32e9262fd706831bf78b04b | /AdvancedSkills/app/src/main/java/com/neo/advancedskills/serializable/Person.java | e69f7b2e33e0229225f1765b5c5d11b20482623e | [] | no_license | hym3991/StudyNote | 6581e3d5473972ebf56024929e02244747e103e1 | 5f7e4f328f481d9ea1d150cde091282ba5662ad8 | refs/heads/master | 2020-04-07T07:39:56.886363 | 2020-03-27T07:00:13 | 2020-03-27T07:00:13 | 158,184,470 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 433 | java | package com.neo.advancedskills.serializable;
import java.io.Serializable;
/**
* Created by Neo on 2019/1/22.
* Description :
*/
public class Person implements Serializable
{
private String name;
private int age;
public String getName()
{
return name;
}
public void setName( String name )
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge( int age )
{
this.age = age;
}
}
| [
"[email protected]"
] | |
2dc6c9422d37f57343d758814a02f983c458a0cb | f51d91292d103226253f4cd0f6ab353b9ad6d333 | /IFTM-POO/src/iftm/poo/simulado1/Programa2.java | b60005152d85f578d5dbdd76416c6a172075f5df | [] | no_license | jmcMartins/optimusJava | 7424eabca40d28a343aeb5f0cc74da3320070f5b | c7d9c16708fdac6c378738633174721a03a6dbe8 | refs/heads/master | 2021-01-22T21:12:36.660850 | 2017-03-18T14:08:21 | 2017-03-18T14:08:21 | 85,404,173 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,747 | java | package iftm.poo.simulado1;
import java.util.Scanner;
public class Programa2 {
public static int randInt(int min, int max){
java.util.Random rand = new java.util.Random();
int randomNum = rand.nextInt( (max - min) + 1) + min;
return randomNum;
}
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
int escolha = 0, pc;
int a=1;
while(a != 0){
System.out.println("Escolha:\n0 - Pedra\n1 - Papel\n2 - Tesoura");
escolha = teclado.nextInt();
if(escolha >=0 && escolha <= 2){
a = 0;
}else
System.out.println("Escolha invalida. Tente novamente!");
}
pc = randInt(0, 2);
switch(escolha){
case 0:
System.out.println("Você escolheu Pedra.");
break;
case 1:
System.out.println("Você escolheu Pael.");
break;
case 2:
System.out.println("Você escolheu Tesoura.");
break;
}
switch(pc){
case 0:
System.out.println("PC escolheu Pedra.");
break;
case 1:
System.out.println("PC escolheu Pael.");
break;
case 2:
System.out.println("PC escolheu Tesoura.");
break;
}
System.out.println();
if(escolha == 0 && pc == 0 || escolha == 0 && pc == 0){
System.out.println("Empate!!");
}else
if(escolha == 1 && pc == 1 || escolha == 1 && pc == 1){
System.out.println("Empate!!");
}else
if(escolha == 2 && pc == 2 || escolha == 2 && pc == 2){
System.out.println("Empate!!");
}
if(escolha == 0 && pc == 2 || escolha == 2 && pc == 0){
System.out.println("Pedra Ganhou!!");
}
if(escolha == 1 && pc == 0 || escolha == 0 && pc == 1){
System.out.println("Papel Ganhou!!");
}
if(escolha == 2 && pc == 1 || escolha == 1 && pc == 2){
System.out.println("Tesoura Ganhou!!");
}
teclado.close();
}
}
| [
"[email protected]"
] | |
2a979256d898c569ab120a535c65739a59635b21 | edee3deb176e8713a17c606bc1652dff3cd860c9 | /app/src/main/java/com/bilgeadam/edu/vkfmobil/sl/ConstantsSL.java | 8b3e2d1350873d44aa4c40bd86af4b4b100143cf | [] | no_license | umutedu/androidedu | 06ab03167a64e698057165a73bd0af49900a1854 | 20d161a770ebfa076fc0004aa895c6d0ae752c1f | refs/heads/master | 2021-05-09T12:45:30.260973 | 2018-01-26T14:06:03 | 2018-01-26T14:06:03 | 119,018,250 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 218 | java | package com.bilgeadam.edu.vkfmobil.sl;
/**
* Created by 02483564 on 6.10.2016.
*/
public class ConstantsSL {
public static String offerings ="offerings";
public static String vodDetails = "vodDetails";
}
| [
"[email protected]"
] | |
26e88df2235073dcec8bc2aa9e0d5e73c4f98e20 | 429857a71c8b1b626c0092eb465ccd6f89ae1584 | /src/Databases/MySqlConnector.java | 6ee24ed5d4f8bbd7b1aa57ad3139f117056ea614 | [] | no_license | chanelnb/Hotel340 | ea645979ab4abc2e9fb2df723f265331a252747c | 4e76d0a3ba7709729ac06a467a2269843af73fa2 | refs/heads/master | 2023-01-30T11:53:54.826738 | 2020-12-02T02:01:43 | 2020-12-02T02:01:43 | 294,442,873 | 0 | 0 | null | 2020-12-01T23:49:38 | 2020-09-10T15:04:15 | Java | UTF-8 | Java | false | false | 8,348 | 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 Databases;
import Main.Main;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.control.Alert;
import javafx.scene.control.ComboBox;
import javafx.scene.control.TextField;
/**
*
* @author chanel
* @author amad
* @author sogol
*
*/
public class MySqlConnector {
PreparedStatement pst;
PreparedStatement pst2;
PreparedStatement pst3;
PreparedStatement pst4;
ResultSet rs;
Stage stage;
Main main = new Main();
public static Connection getConnection() {
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver");
try {
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1/hotelmanagementsystem", "root", "root");
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
} catch (ClassNotFoundException ex) {
System.out.println(ex.getMessage());
}
return con;
}
public MySqlConnector() {
}
public void checkUser(String username, String password) throws IOException {
String query = "SELECT * FROM `user` WHERE username = ? AND password = ?";
try {
pst = getConnection().prepareStatement(query);
pst.setString(1, username);
pst.setString(2, password);
rs = pst.executeQuery();
if (rs.next()) {
//if login successful show a new form
try {
FXMLLoader fxmlLoader = new FXMLLoader();
fxmlLoader.setLocation(getClass().getResource("/Views/HomeScreen.fxml"));
Scene scene = new Scene(fxmlLoader.load(), 600, 400);
Stage stage = new Stage();
stage.setScene(scene);
stage.show();
} catch (IOException e) {
e.printStackTrace();
}
} else {
// if login unsuccessful show error message
Alert alert = new Alert(Alert.AlertType.WARNING);
alert.setTitle("Warning");
alert.setContentText("Invalid username or password");
alert.showAndWait();
}
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
}
public boolean isExist(String email) throws IOException {
String query = "SELECT * FROM `user` WHERE email = ?";
boolean user_exist = false;
try {
pst = getConnection().prepareStatement(query);
pst.setString(1, email);
rs = pst.executeQuery();
if (rs.next()) {
user_exist = true;
}
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
return user_exist;
}
public void userExist(String fname, String lname, String address, String phone, String email, String username, String password) throws IOException {
String query2 = "INSERT into user (uuid, fname, lname, address, phone, email, username, password) values (?,?,?,?,?,?,?,?)";
try {
pst2 = getConnection().prepareStatement(query2);
pst2.setString(1, DataObject.generateUuid());
pst2.setString(2, fname);
pst2.setString(3, lname);
pst2.setString(4, address);
pst2.setString(5, phone);
pst2.setString(6, email);
pst2.setString(7, username);
pst2.setString(8, password);
if (isExist(email)) {
//if user already exists
Alert alert = new Alert(Alert.AlertType.WARNING);
alert.setTitle("Warning");
alert.setContentText("User already exists!");
alert.showAndWait();
} else {
if (pst2.executeUpdate() != 0) {
Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
alert.setTitle("Confirmation");
alert.setContentText("User Created Successsfully, Please signin!");
alert.showAndWait();
FXMLLoader fxmlLoader = new FXMLLoader();
fxmlLoader.setLocation(getClass().getResource("/Views/login.fxml"));
Scene scene = new Scene(fxmlLoader.load());
Stage stage = new Stage();
stage.setScene(scene);
stage.show();
}
}
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void fillFields(String username,TextField nameField, TextField addressField, TextField phoneNumberField) throws IOException {
String query3 = "SELECT * FROM user WHERE username = ?";
try {
pst3 = getConnection().prepareStatement(query3);
pst3.setString(1, username);
rs = pst3.executeQuery();
while (rs.next()) {
// fill in text fiels with pre-existing user info
nameField.setText(rs.getString("fname"));
addressField.setText(rs.getString("address"));
phoneNumberField.setText(rs.getString("phone"));
}
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void reserve(String checkIn, String checkOut, ComboBox roomNum) throws IOException {
String query = "INSERT into reservation (checkin, checkout, roomno) values (?,?,?)";
try {
pst = getConnection().prepareStatement(query);
pst.setString(1, checkIn);
pst.setString(2, checkOut);
pst.setString(3, (String)roomNum.getSelectionModel().getSelectedItem());
// add reservation to database
if (pst.executeUpdate() != 0) {
Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
alert.setTitle("Confirmation");
alert.setContentText("Reservation successfully booked, check your email!");
alert.showAndWait();
}
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void searchBookings(String checkout, ComboBox roomType, ComboBox roomNum) {
String query = "SELECT rooms.roomno, type FROM rooms, reservation WHERE rooms.roomno = reservation.roomno and checkout < ?";
try {
pst = getConnection().prepareStatement(query);
pst.setString(1,checkout);
rs = pst.executeQuery();
if (rs.next() == false) {
// if there are no rooms available show error message
Alert alert = new Alert(Alert.AlertType.WARNING);
alert.setTitle("SORRY");
alert.setContentText("There are no rooms available at this time");
alert.showAndWait();
} else {
do {
// if rooms are available display in combobox
roomType.getItems().addAll(rs.getString("type"));
roomNum.getItems().addAll(rs.getString("roomno"));
} while (rs.next());
}
pst.close();
rs.close();
} catch (SQLException ex) {
Logger.getLogger(MySqlConnector.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
| [
"[email protected]"
] | |
ad261d6e2d50980cfd7742a5b58c8265e2d30ae7 | 0558bde59ea4699e3af128fbf7679d54a6ff855a | /frame/src/payment/src/main/java/com/eastinno/otransos/payment/tencent/mpweixin/utils/http/MySSLSocketFactory.java | 688daf77c885ff679f1863cd9ccccf9e57e03fdf | [] | no_license | lingxfeng/seafood | 758fccfc2ef4ff7b5ec1317de3fde32155cc0939 | 4015e374d373fa7df3de941b727161487610484d | refs/heads/master | 2022-08-12T19:21:34.172827 | 2020-12-15T06:16:53 | 2020-12-15T06:17:08 | 81,176,380 | 1 | 2 | null | 2022-07-07T23:17:42 | 2017-02-07T06:50:25 | JavaScript | UTF-8 | Java | false | false | 1,230 | java | package com.eastinno.otransos.payment.tencent.mpweixin.utils.http;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import org.apache.http.conn.ssl.SSLSocketFactory;
public class MySSLSocketFactory extends SSLSocketFactory{
static{
mySSLSocketFactory = new MySSLSocketFactory(createSContext());
}
private static MySSLSocketFactory mySSLSocketFactory = null;
private static SSLContext createSContext(){
SSLContext sslcontext = null;
try {
sslcontext = SSLContext.getInstance("SSL");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
try {
sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, null);
} catch (KeyManagementException e) {
e.printStackTrace();
return null;
}
return sslcontext;
}
private MySSLSocketFactory(SSLContext sslContext) {
super(sslContext);
this.setHostnameVerifier(ALLOW_ALL_HOSTNAME_VERIFIER);
}
public static MySSLSocketFactory getInstance(){
if(mySSLSocketFactory != null){
return mySSLSocketFactory;
}else{
return mySSLSocketFactory = new MySSLSocketFactory(createSContext());
}
}
} | [
"[email protected]"
] | |
98d34f831fe8d3a27eaa72115c9632b51e143d14 | c368a970f5bc36f8c7054b31c9b16296055bd0d5 | /LabManual9(143-068)/src/labmanual9/pkg143/pkg068/TaskOneMain.java | 4ac1faec5bd9beaa0e132c1e26e29098d3969d0a | [] | no_license | Khadija-Asif/PD9_OOP_143_068 | 7b5a2626107e84366f9f208b33f622338b974b3a | 95d634a585c18a3823d8b9da3686398cedb87918 | refs/heads/main | 2023-04-09T15:44:28.907478 | 2021-04-25T15:01:17 | 2021-04-25T15:01:17 | 361,239,986 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 922 | 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 labmanual9.pkg143.pkg068;
import java.util.Scanner;
/**
*
* @author KHADIJA
*/
public class TaskOneMain {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
stringMethodsOne S = new stringMethodsOne();
System.out.println("Enter the String: ");
String s;
Scanner obj = new Scanner(System.in);
s = obj.nextLine();
S.wordCounter(s);
S.vovelCounter(s);
S.puncCounter(s);
String s1;
System.out.println("Enter subString to check whether it is available in the String or not: ");
s1 = obj.nextLine();
S.findSubString(s, s1);
}
}
| [
"[email protected]"
] | |
380bc9a760447f02d7e3a365d5bea4489afb671e | 1f90b86cb54987c53397d8b57295d291ba512d02 | /src/org.bzdev.math/org/bzdev/math/rv/GaussianIATimeRVRV.java | 46eebddd09073c8718837885a6f2cdf2c7964298 | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
] | permissive | BillZaumen/libbzdev | 2bd97fc98b92320f079e4615e0aad700813c0a53 | 948f0a1fa2bdba91d55b2a2f792f3c89679742af | refs/heads/master | 2023-09-01T11:24:14.811257 | 2023-08-25T03:04:17 | 2023-08-25T03:04:17 | 459,379,399 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,662 | java | package org.bzdev.math.rv;
//@exbundle org.bzdev.math.rv.lpack.RV
/**
* Class to generate a sequence of Gaussian random variables, with the
* values for each rounded to the nearest long integer to represent
* interarrival times.
*/
public class GaussianIATimeRVRV extends InterarrivalTimeRVRV<GaussianIATimeRV> {
static String errorMsg(String key, Object... args) {
return RVErrorMsg.errorMsg(key, args);
}
DoubleRandomVariable meanRV;
DoubleRandomVariable sdevRV;
/**
* Constructor.
* @param meanRV a random variable that determines the mean of the
* distribution for a Gaussian random variable
* @param sdevRV a random variable that determines the standard
* deviation of the distribution for a Gaussian random
* variable
*/
public GaussianIATimeRVRV(DoubleRandomVariable meanRV,
DoubleRandomVariable sdevRV)
{
// clone in case setMinimum or similar methods called.
Class<?> clasz = null;
try {
clasz = meanRV.getClass();
this.meanRV = (DoubleRandomVariable)meanRV.clone();
clasz = sdevRV.getClass();
this.sdevRV = (DoubleRandomVariable)sdevRV.clone();
this.sdevRV.tightenMinimum(0.0, false);
determineIfOrdered(meanRV, sdevRV);
} catch (CloneNotSupportedException e) {
String msg = errorMsg("noClone", clasz.getName());
throw new RandomVariableException(msg, e);
}
}
@Override
protected GaussianIATimeRV doNext() throws RandomVariableException {
return new GaussianIATimeRV(meanRV.next(), sdevRV.next());
}
}
// LocalWords: exbundle interarrival meanRV sdevRV setMinimum
// LocalWords: noClone
| [
"[email protected]"
] | |
75a9e21016177fd836a73643f3359758819ee64a | 3239c6ca99820ef55f611fe1c27f4aa6e1b87f2d | /src/main/java/com/sagatechs/generics/appConfiguration/AppConfiguration.java | 2d21dc6067b2a361bf3466d103d128ccddb0fa85 | [] | no_license | sebasstg/program_monitoring_backend | f54a35d8349031f1b70f5af7ab3d3b517cf16bd6 | 6d6c70795e49c09fbd7a3f8be4f73231a274415e | refs/heads/master | 2022-07-09T08:34:28.759952 | 2020-05-01T05:42:57 | 2020-05-01T05:42:57 | 239,423,843 | 0 | 0 | null | 2022-06-29T17:56:49 | 2020-02-10T04:03:06 | Java | UTF-8 | Java | false | false | 2,295 | java | package com.sagatechs.generics.appConfiguration;
import com.sagatechs.generics.persistence.model.BaseEntity;
import javax.persistence.*;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
@Entity
@Table(name = "app_config", schema = "app_config")
@NamedQuery(name = AppConfiguration.QUERY_FIND_BY_KEY, query = "SELECT o FROM AppConfiguration o WHERE o.clave=:"
+ AppConfiguration.QUERY_PARAM_KEY)
public class AppConfiguration extends BaseEntity<Long> {
public static final String QUERY_FIND_BY_KEY = "AppConfiguration.FindByClave";
public static final String QUERY_PARAM_KEY = "clave";
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@NotNull
@NotEmpty
@Column(name = "nombre", unique = true)
@Size(min = 4, max = 100)
private String nombre;
@NotNull
@NotEmpty
@Column(name = "descripcion", columnDefinition = "TEXT")
private String descripcion;
@NotNull
@Column(name = "clave", unique = true)
@Enumerated(EnumType.STRING)
private AppConfigurationKey clave;
@Size(max = 255)
@Column(name = "valor")
private String valor;
@SuppressWarnings("WeakerAccess")
public AppConfiguration(String nombre, String descripcion, AppConfigurationKey clave, String valor) {
super();
this.nombre = nombre;
this.descripcion = descripcion;
this.clave = clave;
this.valor = valor;
}
public AppConfiguration() {
super();
}
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
public AppConfigurationKey getClave() {
return clave;
}
public void setClave(AppConfigurationKey clave) {
this.clave = clave;
}
public String getValor() {
return valor;
}
public void setValor(String valor) {
this.valor = valor;
}
@Override
public String toString() {
return "AppConfiguration [id=" + id + ", nombre=" + nombre + ", descripcion=" + descripcion + ", clave=" + clave
+ ", valor=" + valor + "]";
}
}
| [
"[email protected]"
] | |
bf210c0a2865334ae3a46788462a2110f8a3db5c | dd9b2e35b69dc986670d6ecd1af18f15dccc0209 | /src/main/java/com/mike/testapp/GlyphUtils.java | f3ab51250dd67ef50eb7075a676cf2de6d79af0b | [] | no_license | elmikex/javafxapp | 29cf12cf47e3c98d5c1566f69e2265e3ddec067b | e4ad167b7867ef8c30e034ab5b86ec7cfb48d95b | refs/heads/master | 2021-01-20T18:28:40.201339 | 2016-08-12T23:57:57 | 2016-08-12T23:57:57 | 62,607,810 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 798 | 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 com.mike.testapp;
import javafx.scene.paint.Color;
import org.controlsfx.glyphfont.Glyph;
/**
*
* @author Mike-MSI
*/
public class GlyphUtils {
public static Glyph getGlyph(String name, int size){
return new Glyph("FontAwesome",name).size(size);
}
public static Glyph getGlyph(String name, String color){
return new Glyph("FontAwesome",name).color(Color.valueOf(color));
}
public static Glyph getGlyph(String name, int size, String color){
return new Glyph("FontAwesome", name).size(size).color(Color.valueOf(color));
}
}
| [
"[email protected]"
] | |
e83991f173c19766ab7da3ad33bf304ba7cce960 | 1a38494705375eaf4a5f5273c961417c3e8caf34 | /app/models/Usuario.java | 8f867efe2535198969479428cd80a758c801dac6 | [
"Apache-2.0"
] | permissive | brginfo05/vote-no-livro | 06d4874aba00a51bdb4cb2d5d3deeed0b26c6f9e | d8cfab02a0660fc474148074fd766cb71cfd061f | refs/heads/master | 2020-05-05T12:35:53.418860 | 2014-10-31T03:06:17 | 2014-10-31T03:06:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 805 | java | package models;
import org.apache.commons.lang3.StringUtils;
import play.data.validation.Constraints;
import javax.persistence.*;
/**
* Created by brg on 25/10/2014.
*/
@Entity
public class Usuario {
@Id
@GeneratedValue
private long id;
@Column(length = 254)
private String email;
private String name;
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public boolean isCadastrado() {
return StringUtils.isNotBlank(name);
}
}
| [
"[email protected]"
] | |
e0b5b898accb3cdfbcec3fd0d9bb3c9ae7b65ac7 | e73f6ad4f6e9312bc95c3432b2161b1cd4546411 | /src/main/java/com/codecool/garden/struct/Main.java | a893a31821976e63969a8b72a00a50578ae60f90 | [] | no_license | PiotrPrzybylak/oop_workshop_garden | 3f228b93b39dd4f573f98e84ac060cbdd79be10c | b4bd1da67ab3cba53e1c29e5332c092de9a799a3 | refs/heads/master | 2023-06-10T11:25:44.515762 | 2021-07-01T19:28:41 | 2021-07-01T19:28:41 | 382,136,977 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 507 | java | package com.codecool.garden.struct;
import java.util.List;
public class Main {
public static void main(String[] args) {
Circle circle1 = new Circle(10.0);
Circle circle2 = new Circle(20.0);
Circle circle3 = new Circle(.5);
Square square1 = new Square(10);
Square square2 = new Square(20);
int area = Garden.howManyBoxesOfGrassSeedsINeedToBuy(List.of(circle1, circle2, circle3), List.of(square1, square2));
System.out.println(area);
}
}
| [
"[email protected]"
] | |
97dbffa48d582b04f0cbb5dd02ae7b460d5b3732 | a6f86658c79fb098f0ff5c7bfc4ad62ccc057f4d | /src/com/efrei/util/md5/MD5Util.java | 3dbd23fa8a646d835ba09390cc89bdf109347ecc | [] | no_license | RITA8421/MD5 | 24bd90275c59f810deb6b52e55c75e88ee5ff9ce | 04a5a720ada978eeb02070b2faf1df2d5453d701 | refs/heads/master | 2021-05-09T05:09:06.779873 | 2018-01-28T22:11:57 | 2018-01-28T22:11:57 | 119,300,784 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,510 | java | package com.efrei.util.md5;
import java.util.Random;
import org.apache.commons.codec.binary.Hex;
import java.security.NoSuchAlgorithmException;
import java.security.MessageDigest;
public class MD5Util {
//MD5 normal
public static String MD5(String input) {
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
return "check jdk";
} catch (Exception e) {
e.printStackTrace();
return "";
}
char[] charArray = input.toCharArray();
byte[] byteArray = new byte[charArray.length];
for (int i = 0; i < charArray.length; i++)
byteArray[i] = (byte) charArray[i];
byte[] md5Bytes = md5.digest(byteArray);
StringBuffer hexValue = new StringBuffer();
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16)
hexValue.append("0");
hexValue.append(Integer.toHexString(val));
}
return hexValue.toString();
}
//MD5 with salt
public static String generate(String password) {
Random r = new Random();
StringBuilder sb = new StringBuilder(16);
sb.append(r.nextInt(99999999)).append(r.nextInt(99999999));
int len = sb.length();
if (len < 16) {
for (int i = 0; i < 16 - len; i++) {
sb.append("0");
}
}
String salt = sb.toString();
// System.out.println("salt: " + salt);
// System.out.println("password: " + password);
// System.out.println("password+salt: " + password + salt);
password = md5Hex(password + salt);
// System.out.println("MD5 with salt:"+ password);
char[] cs = new char[48];
for (int i = 0; i < 48; i += 3) {
cs[i] = password.charAt(i / 3 * 2);
char c = salt.charAt(i / 3);
cs[i + 1] = c;
cs[i + 2] = password.charAt(i / 3 * 2 + 1);
}
return new String(cs);
}
//Verify
public static boolean verify(String password, String md5) {
char[] cs1 = new char[32];
char[] cs2 = new char[16];
for (int i = 0; i < 48; i += 3) {
cs1[i / 3 * 2] = md5.charAt(i);
cs1[i / 3 * 2 + 1] = md5.charAt(i + 2);
cs2[i / 3] = md5.charAt(i + 1);
}
String salt = new String(cs2);
return md5Hex(password + salt).equals(new String(cs1));
}
//Get a hexadecimal string of MD5 function
private static String md5Hex(String src) {
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] bs = md5.digest(src.getBytes());
return new String(new Hex().encode(bs));
} catch (Exception e) {
return null;
}
}
}
| [
"[email protected]"
] | |
8320cf4a4f6fa7baad517aa386696edfc6bfdde2 | d9475c1af6e41fcbec125dfe42f58d33d59efa97 | /target/generated-sources/annotations/org/soptorshi/domain/ExperienceInformation_.java | e9db40db9ec6c51db675481e65dc5acbeed045a5 | [] | no_license | codenodesoft/taro-accounting | 98f8b6dba46c2f2d2667114c83b687cf3e35f83d | 001c1de02c0824b066a74bff117ccdefa5d0f330 | refs/heads/master | 2023-08-28T02:23:57.733688 | 2021-10-13T12:35:29 | 2021-10-13T12:35:29 | 414,500,743 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,033 | java | package org.soptorshi.domain;
import java.time.LocalDate;
import javax.annotation.Generated;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;
import org.soptorshi.domain.enumeration.EmploymentType;
@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
@StaticMetamodel(ExperienceInformation.class)
public abstract class ExperienceInformation_ {
public static volatile SingularAttribute<ExperienceInformation, LocalDate> endDate;
public static volatile SingularAttribute<ExperienceInformation, EmploymentType> employmentType;
public static volatile SingularAttribute<ExperienceInformation, String> organization;
public static volatile SingularAttribute<ExperienceInformation, Long> id;
public static volatile SingularAttribute<ExperienceInformation, String> designation;
public static volatile SingularAttribute<ExperienceInformation, Employee> employee;
public static volatile SingularAttribute<ExperienceInformation, LocalDate> startDate;
}
| [
"[email protected]"
] | |
77377859eb2e624b58b283351f23eab216af9ca8 | f2fac10df618b9ca73689373b4050baa5ee82a3f | /src/bus/station4/Monier.java | c7dbff78989c7dde9c89b07e50ee46986f086f16 | [] | no_license | HagarAbouroumia/BusStation | fc88c22edfd6ba746d5e451def6f0ab87c9768cc | dc5a3922f311cd1ade538cba028b2c7e8772150a | refs/heads/master | 2020-06-22T00:37:18.745661 | 2019-07-18T12:18:26 | 2019-07-18T12:18:26 | 197,590,149 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,458 | 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 bus.station4;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.event.ActionEvent;
import javafx.event.Event;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.layout.GridPane;
import javafx.stage.Stage;
/**
*
* @author user
*/
public class Monier {
Scene scene;
Stage stage;
SaveLists lists;
LogicAuthentication logicAuthentication;
ScenePassengerProfile passengerProfile;
int i = 0;
int k = 0;
int count = 0;
int countN2 = 0;
int countP2 = 0;
ArrayList<Trips> newlist;
ArrayList<TripsForDrivers> newlistAdd;
PassengerOptions passengerOptions;
ManagerOptions managerOptions;
public void setManagerOptions(ManagerOptions managerOptions) {
this.managerOptions = managerOptions;
}
String OneWay = "One Way";
String RoundTrip = "Round Trip";
Label source = new Label();
Label destination = new Label();
Label date = new Label();
Label time = new Label();
Label seats = new Label();
Label type = new Label();
Label price = new Label();
Label returnDate2 = new Label();
Label returnTime2 = new Label();
ComboBox comboBox = new ComboBox();
ComboBox comboBox2 = new ComboBox();
EventHandler<Event> eventHandler;
public void prepareScene(SaveLists save) {
lists = save;
Label wsource = new Label("Source ");
Label wdestination = new Label("Destination ");
Label wdate = new Label("Date ");
Label wtime = new Label("Time ");
Label wType = new Label("Type Of Trip ");
Label label = new Label();
Label finalPrice = new Label();
Button next = new Button("next");
Button prev = new Button("prev");
Button book = new Button("Book");
Button back = new Button("Back");
comboBox.getItems().addAll("No Stop", "One Stop", "Many Stops");
comboBox.setPromptText("Enter no.Stops");
comboBox2.getItems().addAll("One Way", "Round Trip");
comboBox2.setPromptText("Way");
GridPane grid = new GridPane();
grid.setPadding(new Insets(60, 60, 60, 60));
grid.setVgap(10);
grid.setHgap(10);
grid.add(wsource, 0, 0);
grid.add(wdestination, 1, 0);
grid.add(wdate, 2, 0);
grid.add(wtime, 3, 0);
//grid.add(wseats, 4, 0);
grid.add(wType, 5, 0);
// grid.add(wPrice, 6, 0);
grid.add(source, 0, 1);
grid.add(destination, 1, 1);
grid.add(date, 2, 1);
grid.add(time, 3, 1);
// grid.add(seats, 4, 1);
grid.add(type, 5, 1);
grid.add(next, 0, 3);
grid.add(prev, 9, 3);
grid.add(book, 12, 1);
grid.add(back, 12, 2);
newlist = lists.getTrips();
Trips trip = newlist.get(0);
System.out.println(i); //cehck
source.setText(trip.source);
destination.setText(trip.destination);
date.setText(trip.date);
time.setText(trip.Time);
// seats.setText(trip.seats);
type.setText(trip.type);
next.setOnAction(new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
newlist = lists.getTrips();
if (i >= newlist.size()) {
int j = newlist.size();
i = j - 2;
}
if (i < 0) {
i = 0;
}
++i;
if (i >= newlist.size()) {
i = newlist.size() - 1;
return;
}
Trips trip = newlist.get(i);
//
System.out.println(i); //cehck
source.setText(trip.source);
destination.setText(trip.destination);
date.setText(trip.date);
time.setText(trip.Time);
// seats.setText(trip.seats);
type.setText(trip.type);
// price.setText(trip.price);
}
});
prev.setOnAction(new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
newlist = lists.getTrips();
if (i >= newlist.size()) {
int j = newlist.size();
i = j - 1;
}
--i;
if (i < 0) {
i = 0;
return;
}
Trips trip = newlist.get(i);
System.out.println(i);
source.setText(trip.source);
destination.setText(trip.destination);
date.setText(trip.date);
time.setText(trip.Time);
type.setText(trip.type);
}
});
book.setOnAction(new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
String n = "null";
String value = "newTripMonier.txt";
TripsForDrivers trips2 = new TripsForDrivers();
Trips trip = newlist.get(i);
// Trips trip2 = newlist.get(k);
trips2.setSource(trip.source);
trips2.setDestination(trip.destination);
trips2.setDate(trip.date);
trips2.setTime(trip.Time);
trips2.setType(trip.type);
try {
lists.saveTrips3(trips2, value);
} catch (IOException ex) {
} catch (ClassNotFoundException ex) {
Logger.getLogger(ScenePassengerProfile.class.getName()).log(Level.SEVERE, null, ex);
}
newlist.remove(i);
}
});
back.setOnAction(new EventHandler<ActionEvent>() {
public void handle(ActionEvent event) {
label.setText(" ");
finalPrice.setText(" ");
count = 0;
countN2 = 0;
countP2 = 0;
stage.setScene(managerOptions.getScene());
}
});
scene = new Scene(grid, 1700, 400);
}
public Scene getScene() {
return scene;
}
public void setStage(Stage stage) {
this.stage = stage;
}
public void setLists(SaveLists lists) {
this.lists = new SaveLists();
this.lists = lists;
}
public void setPassengerOptions(PassengerOptions passengerOptions) {
this.passengerOptions = passengerOptions;
}
public void setLogicAuthentication(LogicAuthentication logicAuthentication) {
this.logicAuthentication = logicAuthentication;
}
}
| [
"user@DESKTOP-HM24ONF"
] | user@DESKTOP-HM24ONF |
af4cfce2073b92fecbe58d9681159a64380dc1d5 | 3401da116f679203fe324d2f907d7dac65b0ad62 | /social_network_project/src/main/java/ru/javalab/config/ApplicationContextConfig.java | b71d3f95d1ed2b3e71ebf85589a1bbe7f365fb3c | [] | no_license | doggipes/javalab2020 | f84a372623f96ab0394a8a9ed773dee5fdb71592 | 23289196013835b507bcc92489ffd90568868772 | refs/heads/master | 2022-12-25T21:44:14.209203 | 2021-03-09T11:35:55 | 2021-03-09T11:35:55 | 251,171,114 | 0 | 0 | null | 2022-12-16T15:50:38 | 2020-03-30T01:23:48 | Java | UTF-8 | Java | false | false | 4,908 | java | package ru.javalab.config;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer;
import org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Properties;
@Configuration
@PropertySource("classpath:application.properties")
@ComponentScan(basePackages = "ru.javalab")
@EnableTransactionManagement
public class ApplicationContextConfig {
@Autowired
private Environment environment;
@Bean
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(hikariDataSource());
}
@Bean
public ViewResolver viewResolver() {
FreeMarkerViewResolver viewResolver = new FreeMarkerViewResolver();
viewResolver.setContentType("text/html; charset=UTF-8");
viewResolver.setCache(true);
viewResolver.setPrefix("");
viewResolver.setSuffix(".ftlh");
return viewResolver;
}
@Bean
public FreeMarkerConfigurer freemarkerConfig() {
FreeMarkerConfigurer freeMarkerConfigurer = new FreeMarkerConfigurer();
freeMarkerConfigurer.setTemplateLoaderPath("WEB-INF/templates");
freeMarkerConfigurer.setDefaultEncoding("UTF-8");
return freeMarkerConfigurer;
}
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
HibernateJpaVendorAdapter hibernateJpaVendorAdapter = new HibernateJpaVendorAdapter();
LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
entityManagerFactory.setDataSource(hikariDataSource());
entityManagerFactory.setPackagesToScan("ru.javalab");
entityManagerFactory.setJpaVendorAdapter(hibernateJpaVendorAdapter);
entityManagerFactory.setJpaProperties(additionalProperties());
return entityManagerFactory;
}
private Properties additionalProperties() {
Properties properties = new Properties();
properties.setProperty("hibernate.hbm2ddl.auto", "update");
properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
properties.setProperty("hibernate.show_sql", "true");
return properties;
}
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory){
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory);
return transactionManager;
}
@Bean
public HikariConfig hikariConfig() {
HikariConfig config = new HikariConfig();
config.setJdbcUrl(environment.getProperty("db.url"));
config.setUsername(environment.getProperty("db.user"));
config.setPassword(environment.getProperty("db.password"));
config.setDriverClassName(environment.getProperty("db.driver"));
return config;
}
@Bean
public DataSource hikariDataSource() {
return new HikariDataSource(hikariConfig());
}
@Bean
public Properties properties() {
Properties properties = System.getProperties();
properties.put("mail.smtp.port", environment.getProperty("mail.smtp.port"));
properties.put("mail.smtp.host", environment.getProperty("mail.smtp.host"));
properties.put("mail.smtp.auth", environment.getProperty("mail.smtp.auth"));
properties.put("mail.smtp.user", environment.getProperty("mail.smtp.user"));
properties.put("mail.smtp.password", environment.getProperty("mail.smtp.password"));
properties.put("mail.smtp.ssl.enable", environment.getProperty("mail.smtp.ssl.enable"));
properties.put("mail.debug", environment.getProperty("mail.debug"));
return properties;
}
}
| [
"[email protected]"
] | |
0d3c3172c2861d18192fba584817502cf595c634 | 5da063b45a1a478ab3eda1d95c1a8021a09def71 | /app/src/main/java/com/sky/musiclearn/utils/MusicLearnApplication.java | 5208789a7b83fbecaf1d38723e4d615f519a48d3 | [] | no_license | zhongyoubo/MidiPiano | e0203b7b971c2eb97cac08f4e4df5353694cfb9b | c3fd229eca7bb7c6086b15e10b69587cf79d2ce1 | refs/heads/master | 2020-12-08T01:23:10.710806 | 2016-09-01T05:56:26 | 2016-09-01T05:56:26 | 67,101,181 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 414 | java | package com.sky.musiclearn.utils;
import android.app.Application;
import android.content.Context;
/**
* Created by Sky000 on 2016/8/17.
*/
public class MusicLearnApplication extends Application {
public static Context context;
@Override
public void onCreate() {
super.onCreate();
context = getApplicationContext();
MusicLearnConfig.setResolutionAndDpiDiv(context);
}
}
| [
"[email protected]"
] | |
a5763339c54027ad1f7f0e1d888c114527b10cdc | 5136d562df2975fa2dd062e311c60e5905c0b439 | /src/test/java/com/vcu/dbproj/web/rest/TestUtil.java | cfe0a16b24cfded5f63e965ddc06790c02b5df58 | [] | no_license | kleiner617/dbProject | 1c176747a1052d4895b7f64e45348175c452469b | 52f3e07b2745cff4c3bdd14437b8b47b85ae6e8d | refs/heads/master | 2021-01-20T09:02:04.349881 | 2017-05-05T00:35:56 | 2017-05-05T00:35:56 | 90,213,664 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,945 | java | package com.vcu.dbproj.web.rest;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.ser.ZonedDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.http.MediaType;
import java.io.IOException;
import java.nio.charset.Charset;
import java.time.ZonedDateTime;
import static com.vcu.dbproj.config.JacksonConfiguration.ISO_FIXED_FORMAT;
/**
* Utility class for testing REST controllers.
*/
public class TestUtil {
/** MediaType for JSON UTF8 */
public static final MediaType APPLICATION_JSON_UTF8 = new MediaType(
MediaType.APPLICATION_JSON.getType(),
MediaType.APPLICATION_JSON.getSubtype(), Charset.forName("utf8"));
/**
* Convert an object to JSON byte array.
*
* @param object
* the object to convert
* @return the JSON byte array
* @throws IOException
*/
public static byte[] convertObjectToJsonBytes(Object object)
throws IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
JavaTimeModule module = new JavaTimeModule();
module.addSerializer(ZonedDateTime.class, new ZonedDateTimeSerializer(ISO_FIXED_FORMAT));
mapper.registerModule(module);
return mapper.writeValueAsBytes(object);
}
/**
* Create a byte array with a specific size filled with specified data.
*
* @param size the size of the byte array
* @param data the data to put in the byte array
* @return the JSON byte array
*/
public static byte[] createByteArray(int size, String data) {
byte[] byteArray = new byte[size];
for (int i = 0; i < size; i++) {
byteArray[i] = Byte.parseByte(data, 2);
}
return byteArray;
}
}
| [
"[email protected]"
] | |
5f2b9a40727d8ee3bd35316e92080f5e5fff4858 | d0211bce4675ddecc8a544e38d490f194049f505 | /Graph/Unreachable_Nodes.java | 1d4e0fff87a7d17bbd836ff5d30b8e797c7d65fb | [] | no_license | AkhandMishratruth/HackerEarth | c0966bf632473446ae3a2bfce91c18a5bd4396d5 | 715b16c05e259f4d8f2d0d54377b0d7c4e8ce90e | refs/heads/master | 2021-01-21T18:33:31.866360 | 2018-05-21T18:26:16 | 2018-05-21T18:26:16 | 92,059,250 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,537 | java | import java.io.*;
import java.util.*;
public class Unreachable_Nodes {
public static void main(String args[]) throws Exception {
FastReader in = new FastReader();
int v = in.nextInt(), e = in.nextInt();
Graph TheGra = new Graph(v);
for(int i=0;i<e;i++)
TheGra.setEdge(in.nextInt(), in.nextInt());
System.out.println(TheGra.nodesAtLev(in.nextInt())-1);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
class Graph {
Map<Integer, List<Integer>> gra;
boolean[] dist;
Graph(int vertex) {
gra = new HashMap<Integer, List<Integer>>();
dist = new boolean[vertex + 1];
for (int i = 1; i <= vertex; i++)
gra.put(i, new LinkedList<Integer>());
}
void setEdge(int s, int d) {
List<Integer> th = gra.get(s);
th.add(d);
th = gra.get(d);
th.add(s);
}
int nodesAtLev(int s) {
Stack<Integer> q = new Stack<>();
q.push(s);
dist[s]=true;
int temp;
while (!q.isEmpty()) {
temp = q.pop();
//System.out.print(q.size()+" ");
Iterator it = gra.get(temp).iterator();
while (it.hasNext()) {
temp = (Integer)it.next();
if(dist[temp]==false) {
q.push(temp);
dist[temp] = true;
}
}
}
int toret = 0;
for (boolean i : dist)
if (i == false)
toret++;
return toret;
}
} | [
"[email protected]"
] | |
8c59f480ca6ef7d6fa0edf0865221432036e6683 | 51ef482d0a4705e9231efeb3835b45f3f7d6647e | /SEM 6/ITE311/LAB/PROG/New folder/anand/RMIClient.java | ff0b7f071681f62f30404e47a769e3d8088e8299 | [] | no_license | devmukul44/VIT-University-Vellore-Lab-Assignment | 40c4b941371a1261878e2041f55a922d2ea4d08a | 761c2a58b40f8cf9f7f07d3c35b95df850e90b93 | refs/heads/master | 2022-01-10T21:35:10.152193 | 2019-05-01T10:48:31 | 2019-05-01T10:48:31 | 77,526,817 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,118 | java | import java.rmi.Naming;
import java.util.*;
public class RMIClient {
static String message="blank";
static HelloWorld obj=null;
public static void main(String[] args){
try
{
obj=(HelloWorld)Naming.lookup("//"+"localhost:1099"+"/HelloWorld");
Scanner sc=new Scanner(System.in);
int a[][]=new int[2][2];
int b[][]=new int[2][2];
System.out.println("enter a");
for(int i=0;i<2;i++)
{
for(int j=0;j<2;j++)
{
System.out.println("Enter at "+i+", "+j);
a[i][j]=sc.nextInt();
}
}
System.out.println("enter b");
for(int i=0;i<2;i++)
{
for(int j=0;j<2;j++)
{
System.out.println("Enter at "+i+", "+j);
b[i][j]=sc.nextInt();
}
}
int c[][]=obj.helloWorld(a,b);
// System.out.println("Message from the RMI-server was: \""+ message +"\"");
for(int i=0;i<2;i++)
{
for(int j=0;j<2;j++)
{
System.out.print(c[i][j]+"\t");
}
System.out.println();
}
}
catch(Exception e)
{
System.out.println("RMIServer erro: "+ e.getMessage());
e.printStackTrace();
}
}
}
| [
"[email protected]"
] | |
8243d20b68437e830bf89658d204335ac1b17df3 | 27f6a988ec638a1db9a59cf271f24bf8f77b9056 | /Code-Hunt-data/users/User171/Sector1-Level6/attempt003-20140920-235922.java | 5d6629fc3e69c6c864f57ae9f3fa1ac4992bc8bf | [] | no_license | liiabutler/Refazer | 38eaf72ed876b4cfc5f39153956775f2123eed7f | 991d15e05701a0a8582a41bf4cfb857bf6ef47c3 | refs/heads/master | 2021-07-22T06:44:46.453717 | 2017-10-31T01:43:42 | 2017-10-31T01:43:42 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 540 | java |
public class Program {
public static int Puzzle(String s) {
int wordCount = 0;
boolean word = false;
int endOfLine = s.length() - 1;
for (int i = 0; i < s.length(); i++) {
if (Character.isLetter(s.charAt(i)) && i != endOfLine) {
word = true;
} else if (!Character.isLetter(s.charAt(i)) && word) {
wordCount++;
word = false;
} else if (Character.isLetter(s.charAt(i)) && i == endOfLine) {
wordCount++;
}
}
return ++wordCount;
}
} | [
"[email protected]"
] | |
f0f8d7bcc072fc05f3bc9a52ecc468a0fa831035 | 738d892969583dd2948799c521f1a9fd2e06b55a | /src/com/xuhu/LeetCode/ojEveryDay/Y2020/M11/D07/Main.java | 13823a75456bba03f8ea6140051bf1e2023ff79f | [] | no_license | reallyhwc/LeetCode | a4b7875e7f5ed438f86dcd62a3bf0a7be4487631 | 1d41507da86dd3000fafe1ea7c03965bc4e5cb67 | refs/heads/master | 2021-06-23T17:00:59.103785 | 2021-04-13T01:33:21 | 2021-04-13T01:33:21 | 213,626,838 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 198 | java | package com.xuhu.LeetCode.ojEveryDay.Y2020.M11.D07;
public class Main {
public static void main(String[] args){
Solution solution = new Solution();
System.out.println();
}
} | [
"[email protected]"
] | |
5311f565c15db52d788e1f38b4d52f67b18b163f | de25da40b1781f6b76d49a72a9be4f84799701b7 | /app/src/main/java/com/example/robin/hungryeye/helper/RetriveDataFromURL.java | 8197d8c197a035b2c4e71dde66baa289d2795091 | [] | no_license | resgurung/HungryEye | edc5ef00a89590554985b2cf4ab2ce863607b2be | 9bf0498527aec3a6718a25e2d9d8b9ca94ec4c6b | refs/heads/master | 2021-01-10T05:08:22.264190 | 2016-01-12T12:58:14 | 2016-01-12T12:58:14 | 49,499,525 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,666 | java | package com.example.robin.hungryeye.helper;
import android.content.Context;
import android.util.Log;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.VolleyLog;
import com.android.volley.toolbox.JsonArrayRequest;
import com.example.robin.hungryeye.config.AppConfig;
import com.example.robin.hungryeye.config.AppController;
import com.example.robin.hungryeye.frag.Item;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by robin on 12/28/2015.
* retrive all the tables from the server
*
*/
public class RetriveDataFromURL {
private static final String TAG = RetriveDataFromURL.class.getSimpleName();
private ItemDBHandler itemDB;
Context context;
//constructor
public RetriveDataFromURL(/*List<Item>itemArrayList*/ Context context){
//this.itemArrayList = itemArrayList;
this.context = context;
}
public /*List<Item>*/ void retriveItems() {
//crate the volley request obj
//string tag request
String tag_request = "drinks_request";
itemDB = new ItemDBHandler(context);
JsonArrayRequest jsonArrayRequest = new JsonArrayRequest(AppConfig.CONTENT_URL, new Response.Listener<JSONArray>() {
@Override
public void onResponse(JSONArray response) {
//parse json
for (int i = 0; i < response.length(); i++) {
try {
JSONObject obj = response.getJSONObject(i);
/*
item.title = obj.getString("itemname");
item.setTitle(item.title);
item.image = obj.getString("imagepath");
item.setImage(item.image);
item.price = obj.getDouble("price");
item.setPrice(item.price);
item.ratings = obj.getInt("ratings");
item.setRatings(item.ratings);
item.category = obj.getString("category");
item.setCategory(item.category);
*/
String title = obj.getString("itemname");
String imagepath = obj.getString("imagepath");
double price = obj.getDouble("price");
int ratings = obj.getInt("ratings");
String category = obj.getString("category");
//itemDB.addItems(title,imagepath,price,ratings,category);
//type is the jsonArray
/*
item.setTitle(obj.getString("itemname"));
Log.d("RetriveDataFromURL", "itemsname: item:" + item.getTitle());
item.setImage(obj.getString("imagepath"));
Log.d("RetriveDataFromURL", "Imagepath:item:" + item.getImage());
item.setRatings(obj.getInt("ratings"));
Log.d("RetriveDataFromURL", "Ratings:item:" + item.getRatings());
item.setPrice(obj.getDouble("price"));
Log.d("RetriveDataFromURL", "Price:item:" + item.getPrice());
item.setCategory(obj.getString("category"));
Log.d("RetriveDataFromURL", "category:item:" + item.getCategory());*/
} catch (JSONException e) {
e.printStackTrace();
}
}
//notify the data changed to adapter
// adapter.notifyDataSetChanged();
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
VolleyLog.e("Retrival error", new Object[]{error.getStackTrace()});
}
}) {
@Override
public Map<String, String> getParams() {
Map<String, String> p = new HashMap<>();
//the value that gets sent is 'mainmenu' and the key is 'tag'
p.put("tag", "menu");
return p;
}
};
Log.d("sending request", " Request sending...");
AppController.getInstance().addToRequestQueue(jsonArrayRequest, tag_request);
//return itemArrayList;
}
}
| [
"[email protected]"
] | |
62246e9769db0c5568b5588165b3fe8d3d6caa26 | c885ef92397be9d54b87741f01557f61d3f794f3 | /results/JacksonDatabind-108/com.fasterxml.jackson.databind.ObjectReader/BBC-F0-opt-20/tests/28/com/fasterxml/jackson/databind/ObjectReader_ESTest.java | 9e0ee80d3ae703ce008ba4f4a3bb8770ea96e6ce | [
"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 | 3,072,124 | java | /*
* This file was automatically generated by EvoSuite
* Sat Oct 23 20:50:33 GMT 2021
*/
package com.fasterxml.jackson.databind;
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.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.annotation.Nulls;
import com.fasterxml.jackson.annotation.ObjectIdGenerator;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.annotation.ObjectIdResolver;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.annotation.SimpleObjectIdResolver;
import com.fasterxml.jackson.core.Base64Variant;
import com.fasterxml.jackson.core.FormatFeature;
import com.fasterxml.jackson.core.FormatSchema;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonFactoryBuilder;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonPointer;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.JsonpCharacterEscapes;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.PrettyPrinter;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.base.GeneratorBase;
import com.fasterxml.jackson.core.filter.FilteringGeneratorDelegate;
import com.fasterxml.jackson.core.filter.FilteringParserDelegate;
import com.fasterxml.jackson.core.filter.TokenFilter;
import com.fasterxml.jackson.core.filter.TokenFilterContext;
import com.fasterxml.jackson.core.format.MatchStrength;
import com.fasterxml.jackson.core.io.CharacterEscapes;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.JsonReadFeature;
import com.fasterxml.jackson.core.json.JsonWriteFeature;
import com.fasterxml.jackson.core.json.ReaderBasedJsonParser;
import com.fasterxml.jackson.core.json.UTF8JsonGenerator;
import com.fasterxml.jackson.core.json.UTF8StreamJsonParser;
import com.fasterxml.jackson.core.json.WriterBasedJsonGenerator;
import com.fasterxml.jackson.core.json.async.NonBlockingJsonParser;
import com.fasterxml.jackson.core.sym.ByteQuadsCanonicalizer;
import com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer;
import com.fasterxml.jackson.core.type.ResolvedType;
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.JsonParserDelegate;
import com.fasterxml.jackson.core.util.JsonParserSequence;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.InjectableValues;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.PropertyName;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.cfg.BaseSettings;
import com.fasterxml.jackson.databind.cfg.ConfigOverrides;
import com.fasterxml.jackson.databind.cfg.ContextAttributes;
import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig;
import com.fasterxml.jackson.databind.deser.AbstractDeserializer;
import com.fasterxml.jackson.databind.deser.BeanDeserializer;
import com.fasterxml.jackson.databind.deser.BeanDeserializerFactory;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.deser.BuilderBasedDeserializer;
import com.fasterxml.jackson.databind.deser.DataFormatReaders;
import com.fasterxml.jackson.databind.deser.DefaultDeserializationContext;
import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
import com.fasterxml.jackson.databind.deser.DeserializerFactory;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.deser.ValueInstantiators;
import com.fasterxml.jackson.databind.deser.std.StdKeyDeserializers;
import com.fasterxml.jackson.databind.ext.CoreXMLDeserializers;
import com.fasterxml.jackson.databind.ext.DOMDeserializer;
import com.fasterxml.jackson.databind.ext.DOMSerializer;
import com.fasterxml.jackson.databind.ext.NioPathDeserializer;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotationMap;
import com.fasterxml.jackson.databind.introspect.BasicClassIntrospector;
import com.fasterxml.jackson.databind.introspect.ClassIntrospector;
import com.fasterxml.jackson.databind.introspect.SimpleMixInResolver;
import com.fasterxml.jackson.databind.introspect.TypeResolutionContext;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.jsontype.impl.StdSubtypeResolver;
import com.fasterxml.jackson.databind.module.SimpleAbstractTypeResolver;
import com.fasterxml.jackson.databind.module.SimpleDeserializers;
import com.fasterxml.jackson.databind.module.SimpleKeyDeserializers;
import com.fasterxml.jackson.databind.module.SimpleValueInstantiators;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.BigIntegerNode;
import com.fasterxml.jackson.databind.node.BinaryNode;
import com.fasterxml.jackson.databind.node.BooleanNode;
import com.fasterxml.jackson.databind.node.DecimalNode;
import com.fasterxml.jackson.databind.node.DoubleNode;
import com.fasterxml.jackson.databind.node.FloatNode;
import com.fasterxml.jackson.databind.node.IntNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.JsonNodeType;
import com.fasterxml.jackson.databind.node.LongNode;
import com.fasterxml.jackson.databind.node.MissingNode;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.POJONode;
import com.fasterxml.jackson.databind.node.ShortNode;
import com.fasterxml.jackson.databind.node.TextNode;
import com.fasterxml.jackson.databind.node.TreeTraversingParser;
import com.fasterxml.jackson.databind.node.ValueNode;
import com.fasterxml.jackson.databind.ser.DefaultSerializerProvider;
import com.fasterxml.jackson.databind.type.ArrayType;
import com.fasterxml.jackson.databind.type.CollectionLikeType;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapLikeType;
import com.fasterxml.jackson.databind.type.MapType;
import com.fasterxml.jackson.databind.type.PlaceholderForType;
import com.fasterxml.jackson.databind.type.ReferenceType;
import com.fasterxml.jackson.databind.type.ResolvedRecursiveType;
import com.fasterxml.jackson.databind.type.SimpleType;
import com.fasterxml.jackson.databind.type.TypeBindings;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.AccessPattern;
import com.fasterxml.jackson.databind.util.LRUMap;
import com.fasterxml.jackson.databind.util.RootNameLookup;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharConversionException;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PushbackInputStream;
import java.io.Reader;
import java.io.SequenceInputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLStreamHandler;
import java.text.DateFormat;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.SimpleTimeZone;
import java.util.Stack;
import java.util.TimeZone;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
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.MockFileInputStream;
import org.evosuite.runtime.mock.java.io.MockFileOutputStream;
import org.evosuite.runtime.mock.java.io.MockPrintStream;
import org.evosuite.runtime.mock.java.net.MockURI;
import org.evosuite.runtime.mock.java.net.MockURL;
import org.evosuite.runtime.mock.java.text.MockDateFormat;
import org.evosuite.runtime.testdata.EvoSuiteFile;
import org.evosuite.runtime.testdata.EvoSuiteURL;
import org.evosuite.runtime.testdata.FileSystemHandling;
import org.evosuite.runtime.testdata.NetworkHandling;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true)
public class ObjectReader_ESTest extends ObjectReader_ESTest_scaffolding {
@Test(timeout = 4000)
public void test000() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<ObjectReader> linkedHashSet0 = new LinkedHashSet<ObjectReader>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedHashSet0);
assertNotNull(dataFormatReaders0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.with(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false, false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders2.findFormat((InputStream) sequenceInputStream0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders_Match0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match0, false);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test001() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<ObjectReader> linkedHashSet0 = new LinkedHashSet<ObjectReader>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedHashSet0);
assertNotNull(dataFormatReaders0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
MatchStrength matchStrength0 = MatchStrength.SOLID_MATCH;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMinimalMatch(matchStrength0);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.with(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
MatchStrength matchStrength1 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders3 = dataFormatReaders1.withMinimalMatch(matchStrength1);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(matchStrength0.equals((Object)matchStrength1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(matchStrength1.equals((Object)matchStrength0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertNotNull(dataFormatReaders3);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(matchStrength0, matchStrength1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(matchStrength1, matchStrength0);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders1.findFormat((InputStream) sequenceInputStream0);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(matchStrength0.equals((Object)matchStrength1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders_Match0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(matchStrength0, matchStrength1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)59;
DataFormatReaders.Match dataFormatReaders_Match1 = dataFormatReaders3.findFormat(byteArray0);
assertArrayEquals(new byte[] {(byte)59}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(dataFormatReaders_Match1.equals((Object)dataFormatReaders_Match0));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(matchStrength0.equals((Object)matchStrength1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(matchStrength1.equals((Object)matchStrength0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertNotNull(dataFormatReaders_Match1);
assertFalse(linkedHashSet0.contains(objectReader0));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match1.getMatchStrength());
assertFalse(dataFormatReaders_Match1.hasMatch());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders_Match1, dataFormatReaders_Match0);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(matchStrength0, matchStrength1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(matchStrength1, matchStrength0);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match1, true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test002() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<ObjectReader> linkedHashSet0 = new LinkedHashSet<ObjectReader>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedHashSet0);
assertNotNull(dataFormatReaders0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.with(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false, true, false).when(enumeration0).hasMoreElements();
doReturn((Object) null).when(enumeration0).nextElement();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders2.findFormat((InputStream) sequenceInputStream0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders_Match0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match0, true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.SequenceInputStream", e);
}
}
@Test(timeout = 4000)
public void test003() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<ObjectReader> linkedHashSet0 = new LinkedHashSet<ObjectReader>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedHashSet0);
assertNotNull(dataFormatReaders0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.with(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false, false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders2.findFormat((InputStream) sequenceInputStream0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders_Match0);
assertFalse(linkedHashSet0.contains(objectReader0));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match0, true);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test004() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectReader1);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)1;
boolean boolean0 = NetworkHandling.createRemoteTextFile((EvoSuiteURL) null, "*w(/53f*wD{L>u{-");
assertFalse(boolean0);
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)118;
byteArray0[3] = (byte)49;
byteArray0[4] = (byte)118;
byteArray0[5] = (byte) (-5);
byteArray0[6] = (byte) (-26);
byteArray0[7] = (byte)3;
byteArray0[8] = (byte)44;
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory2.createParser(byteArray0, (int) (byte)44, 1);
assertArrayEquals(new byte[] {(byte)1, (byte)1, (byte)118, (byte)49, (byte)118, (byte) (-5), (byte) (-26), (byte)3, (byte)44}, byteArray0);
assertEquals(9, byteArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(uTF8StreamJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertNull(uTF8StreamJsonParser0.currentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
// Undeclared exception!
try {
objectReader1._bind(uTF8StreamJsonParser0, uTF8StreamJsonParser0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 44
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test005() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS;
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
// Undeclared exception!
try {
objectReader2.without(deserializationFeature0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test006() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.readerForUpdating("Gy88CwlU");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withRootName("3.m~}(N/gKB");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectNode objectNode0 = objectMapper0.createObjectNode();
assertNotNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isBigInteger());
ObjectNode objectNode1 = objectNode0.putNull("3.m~}(N/gKB");
assertNotNull(objectNode1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isLong());
assertEquals("", objectNode1.asText());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isEmpty());
assertTrue(objectNode1.isObject());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader1.treeToValue((TreeNode) objectNode0, class0);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// java.lang.String cannot be cast to com.fasterxml.jackson.databind.node.ObjectNode
//
verifyException("com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer$ObjectDeserializer", e);
}
}
@Test(timeout = 4000)
public void test007() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
String string0 = "0LS^>iDaXm#Y>";
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXm#Y>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
double double0 = objectNode0.asDouble();
assertEquals(0.0, double0, 0.01);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isBigDecimal());
assertEquals(0, objectNode1.size());
assertTrue(objectNode1.isEmpty());
assertEquals("", objectNode1.asText());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
Class<ObjectNode> class0 = ObjectNode.class;
JsonNode jsonNode0 = concurrentHashMap0.put("8HB", objectNode1);
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode1.equals((Object)objectNode0));
assertNull(jsonNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isBigDecimal());
assertEquals(0, objectNode1.size());
assertTrue(objectNode1.isEmpty());
assertEquals("", objectNode1.asText());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0, 33);
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertEquals("", arrayNode0.asText());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
JsonParser jsonParser0 = arrayNode0.traverse();
assertNotNull(jsonParser0);
assertFalse(arrayNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertEquals("", arrayNode0.asText());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertNull(jsonParser0.currentToken());
assertNull(jsonParser0.getCurrentToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
DeserializationContext deserializationContext0 = objectMapper0.getDeserializationContext();
assertNotNull(deserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<List> class1 = List.class;
CollectionType collectionType0 = typeFactory0.constructCollectionType(class1, class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(collectionType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertTrue(collectionType0.isInterface());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasHandlers());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
CollectionType collectionType1 = collectionType0.withStaticTyping();
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(collectionType1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertTrue(collectionType0.isInterface());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.hasHandlers());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isConcrete());
assertNotSame(objectReader0, objectReader1);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(objectReader1, objectReader0);
boolean boolean0 = NetworkHandling.createRemoteTextFile((EvoSuiteURL) null, "8HB");
assertFalse(boolean0);
Class<BooleanNode> class2 = BooleanNode.class;
TypeBindings typeBindings0 = TypeBindings.create(class2, (JavaType[]) null);
assertNotNull(typeBindings0);
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
ReferenceType referenceType0 = ReferenceType.construct((Class<?>) class2, typeBindings0, (JavaType) collectionType1, (JavaType[]) null, (JavaType) collectionType0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(referenceType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertTrue(collectionType0.isInterface());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.hasHandlers());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isConcrete());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(objectReader1, objectReader0);
ReferenceType referenceType1 = referenceType0.withContentValueHandler(objectNode0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(referenceType1.equals((Object)referenceType0));
assertNotNull(referenceType1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertTrue(collectionType0.isInterface());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.hasHandlers());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isConcrete());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertTrue(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAbstract());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectNode0, objectNode1);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
ReferenceType referenceType2 = (ReferenceType)typeFactory0.moreSpecificType(referenceType0, referenceType1);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertNotNull(referenceType2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertTrue(collectionType0.isInterface());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.hasHandlers());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isConcrete());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType2.isReferenceType());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.isArrayType());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.useStaticType());
assertFalse(referenceType2.isJavaLangObject());
assertTrue(referenceType2.isConcrete());
assertEquals(0, referenceType2.containedTypeCount());
assertFalse(referenceType2.isAbstract());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.hasValueHandler());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isFinal());
assertTrue(referenceType2.isAnchorType());
assertFalse(referenceType2.hasHandlers());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectNode0, objectNode1);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
IntNode intNode0 = new IntNode((-1913347656));
assertNotNull(intNode0);
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.booleanValue());
assertEquals((-1.913347656E9), intNode0.doubleValue(), 0.01);
assertFalse(intNode0.isBigDecimal());
assertEquals((-1913347656L), intNode0.longValue());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.isInt());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isMissingNode());
assertTrue(intNode0.isEmpty());
assertEquals((short) (-24136), intNode0.shortValue());
assertFalse(intNode0.isBigInteger());
assertTrue(intNode0.canConvertToInt());
assertFalse(intNode0.isNaN());
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isShort());
assertEquals((-1913347656), intNode0.intValue());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isFloatingPointNumber());
assertEquals((-1.91334771E9F), intNode0.floatValue(), 0.01F);
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertTrue(intNode0.canConvertToLong());
assertNull(intNode0.textValue());
// Undeclared exception!
try {
objectReader1._prefetchRootDeserializer(referenceType0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test008() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<IntNode> class0 = IntNode.class;
ObjectReader objectReader2 = objectReader1.forType(class0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
DeserializationContext deserializationContext0 = objectMapper1.getDeserializationContext();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(deserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8192, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8192, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory2 = jsonFactory1.setCharacterEscapes(jsonpCharacterEscapes0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8192, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8192, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8192, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonParser_Feature0, true);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
NonBlockingJsonParser nonBlockingJsonParser0 = (NonBlockingJsonParser)jsonFactory3.createNonBlockingByteArrayParser();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(nonBlockingJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertTrue(nonBlockingJsonParser0.canParseAsync());
assertEquals(8193, nonBlockingJsonParser0.getFeatureMask());
assertFalse(nonBlockingJsonParser0.canReadObjectId());
assertTrue(nonBlockingJsonParser0.needMoreInput());
assertFalse(nonBlockingJsonParser0.canReadTypeId());
assertNull(nonBlockingJsonParser0.currentToken());
assertNull(nonBlockingJsonParser0.getCurrentName());
assertNull(nonBlockingJsonParser0.getLastClearedToken());
assertFalse(nonBlockingJsonParser0.hasCurrentToken());
assertFalse(nonBlockingJsonParser0.isExpectedStartArrayToken());
assertFalse(nonBlockingJsonParser0.requiresCustomCodec());
assertEquals(0, nonBlockingJsonParser0.getTextLength());
assertEquals(0, nonBlockingJsonParser0.getFormatFeatures());
assertEquals(0, nonBlockingJsonParser0.getCurrentTokenId());
assertFalse(nonBlockingJsonParser0.isClosed());
assertEquals(0L, nonBlockingJsonParser0.getTokenCharacterOffset());
assertEquals(0, nonBlockingJsonParser0.getTextOffset());
assertNull(nonBlockingJsonParser0.getCurrentToken());
assertEquals(1, nonBlockingJsonParser0.getTokenLineNr());
assertFalse(nonBlockingJsonParser0.hasTextCharacters());
assertFalse(nonBlockingJsonParser0.isNaN());
assertFalse(nonBlockingJsonParser0.isExpectedStartObjectToken());
assertEquals(1, nonBlockingJsonParser0.getTokenColumnNr());
assertEquals(0, nonBlockingJsonParser0.currentTokenId());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
JsonToken jsonToken0 = objectReader0._initForReading(deserializationContext0, nonBlockingJsonParser0);
assertEquals(JsonToken.NOT_AVAILABLE, jsonToken0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertTrue(nonBlockingJsonParser0.canParseAsync());
assertEquals(8193, nonBlockingJsonParser0.getFeatureMask());
assertFalse(nonBlockingJsonParser0.canReadObjectId());
assertTrue(nonBlockingJsonParser0.needMoreInput());
assertFalse(nonBlockingJsonParser0.canReadTypeId());
assertNull(nonBlockingJsonParser0.currentToken());
assertNull(nonBlockingJsonParser0.getCurrentName());
assertNull(nonBlockingJsonParser0.getLastClearedToken());
assertFalse(nonBlockingJsonParser0.hasCurrentToken());
assertFalse(nonBlockingJsonParser0.isExpectedStartArrayToken());
assertFalse(nonBlockingJsonParser0.requiresCustomCodec());
assertEquals(0, nonBlockingJsonParser0.getTextLength());
assertEquals(0, nonBlockingJsonParser0.getFormatFeatures());
assertEquals(0, nonBlockingJsonParser0.getCurrentTokenId());
assertFalse(nonBlockingJsonParser0.isClosed());
assertEquals(0L, nonBlockingJsonParser0.getTokenCharacterOffset());
assertEquals(0, nonBlockingJsonParser0.getTextOffset());
assertNull(nonBlockingJsonParser0.getCurrentToken());
assertEquals(1, nonBlockingJsonParser0.getTokenLineNr());
assertFalse(nonBlockingJsonParser0.hasTextCharacters());
assertFalse(nonBlockingJsonParser0.isNaN());
assertFalse(nonBlockingJsonParser0.isExpectedStartObjectToken());
assertEquals(1, nonBlockingJsonParser0.getTokenColumnNr());
assertEquals(0, nonBlockingJsonParser0.currentTokenId());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertEquals((-1), jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
ContextAttributes.Impl contextAttributes_Impl0 = (ContextAttributes.Impl)objectReader0.getAttributes();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(contextAttributes_Impl0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
}
@Test(timeout = 4000)
public void test009() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<IntNode> linkedHashSet0 = new LinkedHashSet<IntNode>();
assertNotNull(linkedHashSet0);
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
BaseSettings baseSettings0 = ObjectMapper.DEFAULT_BASE;
assertNotNull(baseSettings0);
assertFalse(baseSettings0.hasExplicitTimeZone());
Stack<Locale.LanguageRange> stack0 = new Stack<Locale.LanguageRange>();
assertNotNull(stack0);
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
HashSet<Locale> hashSet0 = new HashSet<Locale>();
assertNotNull(hashSet0);
assertEquals(0, hashSet0.size());
assertTrue(hashSet0.isEmpty());
Locale locale0 = Locale.lookup(stack0, hashSet0);
assertNull(locale0);
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
assertEquals(0, hashSet0.size());
assertTrue(hashSet0.isEmpty());
BaseSettings baseSettings1 = baseSettings0.with((Locale) null);
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertNotNull(baseSettings1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertNotSame(baseSettings0, baseSettings1);
assertNotSame(baseSettings1, baseSettings0);
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = objectMapper0._configOverrides;
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig(baseSettings1, stdSubtypeResolver0, (SimpleMixInResolver) null, rootNameLookup0, configOverrides0);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertNotNull(deserializationConfig0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
ObjectReader objectReader1 = new ObjectReader(objectMapper0, deserializationConfig0);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
objectReaderArray0[0] = objectReader1;
ObjectReader objectReader2 = objectReader1.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNotSame(baseSettings0, baseSettings1);
assertNotSame(baseSettings1, baseSettings0);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
Class<SimpleType> class0 = SimpleType.class;
// Undeclared exception!
try {
objectReader2.forType(class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test010() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<IntNode> linkedHashSet0 = new LinkedHashSet<IntNode>();
assertNotNull(linkedHashSet0);
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) linkedHashSet0, (Object) linkedHashSet0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(collection0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
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);
PropertyName propertyName0 = PropertyName.USE_DEFAULT;
assertNotNull(propertyName0);
assertFalse(propertyName0.hasSimpleName());
assertTrue(propertyName0.isEmpty());
assertEquals("", propertyName0.getSimpleName());
assertFalse(propertyName0.hasNamespace());
assertNull(propertyName0.getNamespace());
IOContext iOContext0 = new IOContext(bufferRecycler0, propertyName0, false);
assertNotNull(iOContext0);
assertFalse(propertyName0.hasSimpleName());
assertTrue(propertyName0.isEmpty());
assertEquals("", propertyName0.getSimpleName());
assertFalse(propertyName0.hasNamespace());
assertNull(propertyName0.getNamespace());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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 charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1935630985), (Reader) null, objectMapper0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(propertyName0.hasSimpleName());
assertTrue(propertyName0.isEmpty());
assertEquals("", propertyName0.getSimpleName());
assertFalse(propertyName0.hasNamespace());
assertNull(propertyName0.getNamespace());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1935630985), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)objectReader0._considerFilter(readerBasedJsonParser0, true);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(propertyName0.hasSimpleName());
assertTrue(propertyName0.isEmpty());
assertEquals("", propertyName0.getSimpleName());
assertFalse(propertyName0.hasNamespace());
assertNull(propertyName0.getNamespace());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1935630985), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-1935630985), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
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);
assertNotSame(objectReader0, objectReader1);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
}
@Test(timeout = 4000)
public void test011() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ContextAttributes contextAttributes1 = contextAttributes0.withoutSharedAttribute(objectMapper0);
assertNotNull(contextAttributes1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(contextAttributes0, contextAttributes1);
assertSame(contextAttributes1, contextAttributes0);
HashMap<NullNode, FloatNode> hashMap0 = new HashMap<NullNode, FloatNode>();
assertNotNull(hashMap0);
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
ContextAttributes contextAttributes2 = contextAttributes1.withSharedAttributes(hashMap0);
assertFalse(contextAttributes2.equals((Object)contextAttributes1));
assertFalse(contextAttributes2.equals((Object)contextAttributes0));
assertNotNull(contextAttributes2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
assertNotSame(contextAttributes0, contextAttributes2);
assertSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes2);
assertSame(contextAttributes1, contextAttributes0);
assertNotSame(contextAttributes2, contextAttributes1);
assertNotSame(contextAttributes2, contextAttributes0);
ObjectReader objectReader0 = objectMapper0.reader(contextAttributes2);
assertFalse(contextAttributes0.equals((Object)contextAttributes2));
assertFalse(contextAttributes1.equals((Object)contextAttributes2));
assertFalse(contextAttributes2.equals((Object)contextAttributes1));
assertFalse(contextAttributes2.equals((Object)contextAttributes0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
assertNotSame(contextAttributes0, contextAttributes2);
assertSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes2);
assertSame(contextAttributes1, contextAttributes0);
assertNotSame(contextAttributes2, contextAttributes1);
assertNotSame(contextAttributes2, contextAttributes0);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
ClassLoader classLoader0 = ClassLoader.getSystemClassLoader();
assertNotNull(classLoader0);
ObjectNode objectNode0 = objectMapper0.createObjectNode();
assertNotNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isShort());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isObject());
String string0 = "Current token not START_OBJECT (needed to unwrap root name '%s'), but %s";
ArrayNode arrayNode0 = objectNode0.withArray("Current token not START_OBJECT (needed to unwrap root name '%s'), but %s");
assertNotNull(arrayNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isShort());
assertTrue(objectNode0.isObject());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isFloatingPointNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
NullNode nullNode0 = arrayNode0.nullNode();
assertNotNull(nullNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isShort());
assertTrue(objectNode0.isObject());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isFloatingPointNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertFalse(nullNode0.isIntegralNumber());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isArray());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isBigInteger());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isFloat());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertEquals("null", nullNode0.asText());
assertEquals(0, nullNode0.size());
FloatNode floatNode0 = new FloatNode(544.6588F);
assertNotNull(floatNode0);
assertFalse(floatNode0.isMissingNode());
assertFalse(floatNode0.isLong());
assertFalse(floatNode0.isDouble());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, floatNode0.asToken());
assertFalse(floatNode0.isArray());
assertTrue(floatNode0.isFloat());
assertNull(floatNode0.textValue());
assertEquals(JsonParser.NumberType.FLOAT, floatNode0.numberType());
assertEquals(544L, floatNode0.longValue());
assertTrue(floatNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.NUMBER, floatNode0.getNodeType());
assertTrue(floatNode0.canConvertToLong());
assertFalse(floatNode0.booleanValue());
assertTrue(floatNode0.canConvertToInt());
assertEquals(0, floatNode0.size());
assertFalse(floatNode0.isNaN());
assertEquals(544, floatNode0.intValue());
assertFalse(floatNode0.isInt());
assertFalse(floatNode0.isShort());
assertFalse(floatNode0.isBigInteger());
assertEquals(544.6588F, floatNode0.floatValue(), 0.01F);
assertEquals((short)544, floatNode0.shortValue());
assertTrue(floatNode0.isEmpty());
assertFalse(floatNode0.isBigDecimal());
assertFalse(floatNode0.isObject());
assertEquals(544.6588134765625, floatNode0.doubleValue(), 0.01);
assertFalse(floatNode0.isIntegralNumber());
FloatNode floatNode1 = hashMap0.put(nullNode0, floatNode0);
assertNull(floatNode1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(hashMap0.isEmpty());
assertEquals(1, hashMap0.size());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isShort());
assertTrue(objectNode0.isObject());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isFloatingPointNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertFalse(nullNode0.isIntegralNumber());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isArray());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isBigInteger());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isFloat());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertEquals("null", nullNode0.asText());
assertEquals(0, nullNode0.size());
assertFalse(floatNode0.isMissingNode());
assertFalse(floatNode0.isLong());
assertFalse(floatNode0.isDouble());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, floatNode0.asToken());
assertFalse(floatNode0.isArray());
assertTrue(floatNode0.isFloat());
assertNull(floatNode0.textValue());
assertEquals(JsonParser.NumberType.FLOAT, floatNode0.numberType());
assertEquals(544L, floatNode0.longValue());
assertTrue(floatNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.NUMBER, floatNode0.getNodeType());
assertTrue(floatNode0.canConvertToLong());
assertFalse(floatNode0.booleanValue());
assertTrue(floatNode0.canConvertToInt());
assertEquals(0, floatNode0.size());
assertFalse(floatNode0.isNaN());
assertEquals(544, floatNode0.intValue());
assertFalse(floatNode0.isInt());
assertFalse(floatNode0.isShort());
assertFalse(floatNode0.isBigInteger());
assertEquals(544.6588F, floatNode0.floatValue(), 0.01F);
assertEquals((short)544, floatNode0.shortValue());
assertTrue(floatNode0.isEmpty());
assertFalse(floatNode0.isBigDecimal());
assertFalse(floatNode0.isObject());
assertEquals(544.6588134765625, floatNode0.doubleValue(), 0.01);
assertFalse(floatNode0.isIntegralNumber());
ClassLoader classLoader1 = classLoader0.getParent();
assertFalse(classLoader1.equals((Object)classLoader0));
assertNotNull(classLoader1);
TypeFactory typeFactory1 = typeFactory0.withClassLoader(classLoader1);
assertFalse(classLoader0.equals((Object)classLoader1));
assertFalse(classLoader1.equals((Object)classLoader0));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(typeFactory1);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
classLoader1.setPackageAssertionStatus("w=GG|J2=`5", true);
assertFalse(classLoader0.equals((Object)classLoader1));
assertFalse(classLoader1.equals((Object)classLoader0));
Class<Map> class0 = Map.class;
Class<IntNode> class1 = IntNode.class;
MapType mapType0 = typeFactory1.constructMapType(class0, class1, class1);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(classLoader0.equals((Object)classLoader1));
assertFalse(classLoader1.equals((Object)classLoader0));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(mapType0);
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.isCollectionLikeType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.hasValueHandler());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.isLong());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertEquals(0, missingNode0.size());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isObject());
assertEquals("", missingNode0.asText());
assertNull(missingNode0.textValue());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isBigInteger());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isBigDecimal());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isFloat());
FloatNode floatNode2 = hashMap0.getOrDefault(missingNode0, (FloatNode) null);
assertNull(floatNode2);
assertFalse(hashMap0.isEmpty());
assertEquals(1, hashMap0.size());
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.isLong());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertEquals(0, missingNode0.size());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isObject());
assertEquals("", missingNode0.asText());
assertNull(missingNode0.textValue());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isBigInteger());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isBigDecimal());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isFloat());
// Undeclared exception!
try {
objectReader0.withType((JavaType) mapType0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test012() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
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);
PlaceholderForType placeholderForType0 = new PlaceholderForType(3);
assertNotNull(placeholderForType0);
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isEnumType());
IOContext iOContext0 = new IOContext(bufferRecycler0, placeholderForType0, true);
assertNotNull(iOContext0);
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isEnumType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
PipedReader pipedReader0 = new PipedReader(3);
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1258990117));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1920, pipedReader0, objectReader0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isEnumType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1920, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.skipChildren();
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isEnumType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1920, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1920, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(objectReader0, objectReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
try {
objectReader0._bind(readerBasedJsonParser1, objectReader1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test013() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_MISSING_CREATOR_PROPERTIES;
NonBlockingJsonParser nonBlockingJsonParser0 = (NonBlockingJsonParser)jsonFactory0.createNonBlockingByteArrayParser();
assertNotNull(nonBlockingJsonParser0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertNull(nonBlockingJsonParser0.getLastClearedToken());
assertFalse(nonBlockingJsonParser0.canReadTypeId());
assertTrue(nonBlockingJsonParser0.needMoreInput());
assertFalse(nonBlockingJsonParser0.requiresCustomCodec());
assertEquals(0, nonBlockingJsonParser0.getFormatFeatures());
assertTrue(nonBlockingJsonParser0.canParseAsync());
assertEquals(8193, nonBlockingJsonParser0.getFeatureMask());
assertFalse(nonBlockingJsonParser0.canReadObjectId());
assertFalse(nonBlockingJsonParser0.isExpectedStartArrayToken());
assertEquals(1, nonBlockingJsonParser0.getTokenLineNr());
assertEquals(0, nonBlockingJsonParser0.getTextLength());
assertNull(nonBlockingJsonParser0.getCurrentName());
assertFalse(nonBlockingJsonParser0.isClosed());
assertFalse(nonBlockingJsonParser0.hasCurrentToken());
assertNull(nonBlockingJsonParser0.getCurrentToken());
assertEquals(0, nonBlockingJsonParser0.getCurrentTokenId());
assertFalse(nonBlockingJsonParser0.isNaN());
assertEquals(0, nonBlockingJsonParser0.getTextOffset());
assertEquals(0, nonBlockingJsonParser0.currentTokenId());
assertEquals(0L, nonBlockingJsonParser0.getTokenCharacterOffset());
assertFalse(nonBlockingJsonParser0.hasTextCharacters());
assertNull(nonBlockingJsonParser0.currentToken());
assertEquals(1, nonBlockingJsonParser0.getTokenColumnNr());
assertFalse(nonBlockingJsonParser0.isExpectedStartObjectToken());
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
ObjectReader objectReader1 = objectReader0.without(jsonParser_Feature0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonParser.Feature[] jsonParser_FeatureArray0 = new JsonParser.Feature[4];
jsonParser_FeatureArray0[0] = jsonParser_Feature0;
jsonParser_FeatureArray0[1] = jsonParser_Feature0;
jsonParser_FeatureArray0[2] = jsonParser_Feature0;
jsonParser_FeatureArray0[3] = jsonParser_Feature0;
ObjectReader objectReader2 = objectReader1.withFeatures(jsonParser_FeatureArray0);
assertEquals(4, jsonParser_FeatureArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
// Undeclared exception!
try {
objectReader0._bindAsTree(nonBlockingJsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test014() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
// Undeclared exception!
try {
objectReader1.withType(class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test015() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)48;
IntNode intNode0 = (IntNode)objectReader0.readTree(byteArray0);
assertArrayEquals(new byte[] {(byte)48}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(intNode0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isBigDecimal());
assertTrue(intNode0.canConvertToInt());
assertEquals(0L, intNode0.longValue());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isMissingNode());
assertEquals((short)0, intNode0.shortValue());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isFloat());
assertTrue(intNode0.isEmpty());
assertEquals(0.0F, intNode0.floatValue(), 0.01F);
assertTrue(intNode0.canConvertToLong());
assertEquals(0.0, intNode0.doubleValue(), 0.01);
assertFalse(intNode0.isObject());
assertNull(intNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isShort());
assertEquals(0, intNode0.size());
assertFalse(intNode0.booleanValue());
assertEquals(0, intNode0.intValue());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test016() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("$-!=t1y-V-APJn9Q");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = objectMapper0.createObjectNode();
assertNotNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertEquals(0, objectNode0.size());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.textValue());
ObjectNode objectNode1 = objectNode0.put("$-!=t1y-V-APJn9Q", 33);
assertNotNull(objectNode1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertEquals(1, objectNode0.size());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.textValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isEmpty());
assertTrue(objectNode1.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isLong());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) objectNode1, (Class<ObjectNode>) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test017() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("{%\"Y k!uGMqT", "{%\"Y k!uGMqT");
assertNotNull(mockFile0);
SimpleTimeZone simpleTimeZone0 = new SimpleTimeZone((-1745846666), "{l$`^QbE<{");
assertNotNull(simpleTimeZone0);
assertEquals("java.util.SimpleTimeZone[id={l$`^QbE<{,offset=-1745846666,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0]", simpleTimeZone0.toString());
assertEquals(0, simpleTimeZone0.getDSTSavings());
assertEquals((-1745846666), simpleTimeZone0.getRawOffset());
assertFalse(simpleTimeZone0.useDaylightTime());
assertEquals("{l$`^QbE<{", simpleTimeZone0.getID());
// Undeclared exception!
try {
objectReader1.with((TimeZone) simpleTimeZone0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test018() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("{%\"Y k!uGMqT", "{%\"Y k!uGMqT");
assertNotNull(mockFile0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES;
// Undeclared exception!
try {
objectReader1.with(deserializationFeature0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test019() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<IntNode> linkedHashSet0 = new LinkedHashSet<IntNode>();
assertNotNull(linkedHashSet0);
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) linkedHashSet0, (Object) linkedHashSet0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(objectMapper0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0);
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isMissingNode());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertTrue(arrayNode0.isArray());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isFloat());
assertEquals("", arrayNode0.asText());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isDouble());
JsonParser jsonParser0 = arrayNode0.traverse();
assertNotNull(jsonParser0);
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isMissingNode());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertTrue(arrayNode0.isArray());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isFloat());
assertEquals("", arrayNode0.asText());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isDouble());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.isClosed());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
// Undeclared exception!
try {
objectReader1.readValues(jsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// Could not initialize class com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.deser.DeserializerCache", e);
}
}
@Test(timeout = 4000)
public void test020() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
IntNode intNode0 = IntNode.valueOf((-2077062426));
assertNotNull(intNode0);
assertFalse(intNode0.isObject());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isFloatingPointNumber());
assertEquals((-2077062426L), intNode0.longValue());
assertEquals((-2.077062426E9), intNode0.doubleValue(), 0.01);
assertEquals(0, intNode0.size());
assertFalse(intNode0.isNaN());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isMissingNode());
assertEquals((-2077062426), intNode0.intValue());
assertEquals((-2.0770624E9F), intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isArray());
assertFalse(intNode0.isBigDecimal());
assertEquals((short) (-29978), intNode0.shortValue());
assertFalse(intNode0.booleanValue());
assertTrue(intNode0.canConvertToInt());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isFloat());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertTrue(intNode0.canConvertToLong());
assertNull(intNode0.textValue());
assertFalse(intNode0.isShort());
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(2, BufferRecycler.CHAR_TEXT_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);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
PipedReader pipedReader0 = new PipedReader(1);
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1307), pipedReader0, objectMapper0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-1307), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
Class<MapType> class0 = MapType.class;
ArrayType arrayType0 = typeFactory0.constructArrayType(class0);
assertNotNull(arrayType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.hasValueHandler());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.isJavaLangObject());
assertFalse(arrayType0.useStaticType());
assertFalse(arrayType0.isAbstract());
assertTrue(arrayType0.isArrayType());
assertTrue(arrayType0.isContainerType());
assertTrue(arrayType0.isConcrete());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isEnumType());
assertFalse(arrayType0.isCollectionLikeType());
try {
objectReader0._verifyNoTrailingTokens(readerBasedJsonParser0, (DeserializationContext) null, arrayType0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test021() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[9];
byte byte0 = (byte)1;
byteArray0[0] = (byte)1;
byteArray0[1] = (byte) (-113);
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.STRICT_DUPLICATE_DETECTION;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(287, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(287, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 239, 239);
assertArrayEquals(new byte[] {(byte)1, (byte) (-113), (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(9, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals((-230), byteArrayInputStream0.available());
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory0.createParser((InputStream) byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)1, (byte) (-113), (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(9, byteArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(287, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals((-230), byteArrayInputStream0.available());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertNull(uTF8StreamJsonParser0.currentToken());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertSame(jsonFactory0, jsonFactory1);
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) uTF8StreamJsonParser0, (JavaType) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test022() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
NullNode nullNode0 = NullNode.getInstance();
assertNotNull(nullNode0);
assertTrue(nullNode0.isEmpty());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isBigInteger());
assertEquals("null", nullNode0.asText());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertEquals(0, nullNode0.size());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.isBigDecimal());
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
BigInteger bigInteger0 = BigInteger.TEN;
assertNotNull(bigInteger0);
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
MissingNode missingNode0 = objectReader0.readValue((JsonNode) nullNode0);
assertNull(missingNode0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(nullNode0.isEmpty());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isBigInteger());
assertEquals("null", nullNode0.asText());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertEquals(0, nullNode0.size());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.isBigDecimal());
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL;
ObjectReader objectReader1 = objectReader0.without(deserializationFeature0);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
Class<List> class1 = List.class;
Class<ArrayType> class2 = ArrayType.class;
CollectionType collectionType0 = typeFactory0.constructCollectionType(class1, class2);
assertNotNull(collectionType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isAbstract());
assertTrue(collectionType0.isCollectionLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertSame(objectReader0, objectReader1);
CollectionType collectionType1 = collectionType0.withStaticTyping();
assertTrue(collectionType1.equals((Object)collectionType0));
assertNotNull(collectionType1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isAbstract());
assertTrue(collectionType0.isCollectionLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType0.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.isPrimitive());
assertTrue(collectionType1.isInterface());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.isMapLikeType());
assertFalse(collectionType1.hasValueHandler());
assertTrue(collectionType1.useStaticType());
assertFalse(collectionType1.isEnumType());
assertFalse(collectionType1.hasHandlers());
assertTrue(collectionType1.isCollectionLikeType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isFinal());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isContainerType());
assertSame(objectReader0, objectReader1);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
// Undeclared exception!
try {
objectReader1.readValue((JsonParser) null, (ResolvedType) collectionType1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test023() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withValueToUpdate(objectReader0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectReader0);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
char[] charArray0 = new char[4];
Class<PropertyName> class0 = PropertyName.class;
NamedType namedType0 = new NamedType(class0, "M~ZXo{N5hlv.H[f1:");
assertNotNull(namedType0);
assertEquals("M~ZXo{N5hlv.H[f1:", namedType0.getName());
assertTrue(namedType0.hasName());
ObjectReader objectReader3 = objectReader0.withAttribute(jsonFactory0, namedType0);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("M~ZXo{N5hlv.H[f1:", namedType0.getName());
assertTrue(namedType0.hasName());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader0);
charArray0[0] = '!';
charArray0[1] = 'b';
charArray0[2] = 'E';
charArray0[3] = 's';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory1.createParser(charArray0);
assertArrayEquals(new char[] {'!', 'b', 'E', 's'}, charArray0);
assertEquals(4, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParserDelegate jsonParserDelegate0 = new JsonParserDelegate(readerBasedJsonParser0);
assertArrayEquals(new char[] {'!', 'b', 'E', 's'}, charArray0);
assertEquals(4, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonParserDelegate0);
assertFalse(jsonParserDelegate0.requiresCustomCodec());
assertFalse(jsonParserDelegate0.canParseAsync());
assertEquals(0, jsonParserDelegate0.getFormatFeatures());
assertEquals(8193, jsonParserDelegate0.getFeatureMask());
assertFalse(jsonParserDelegate0.canReadTypeId());
assertFalse(jsonParserDelegate0.canReadObjectId());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
// Undeclared exception!
try {
objectReader2.readValues((JsonParser) jsonParserDelegate0, (JavaType) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test024() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[5];
ObjectReader[] objectReaderArray0 = new ObjectReader[2];
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
objectReaderArray0[0] = objectReader0;
Class<POJONode> class0 = POJONode.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
objectReaderArray0[1] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(2, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
String string0 = dataFormatReaders0.toString();
assertEquals("[JSON, JSON]", string0);
assertEquals(2, objectReaderArray0.length);
assertNotNull(string0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
MockFile mockFile0 = new MockFile("*Fh", "w3V;p,Z1j|");
assertNotNull(mockFile0);
File file0 = MockFile.createTempFile("+2|{,<(}{i>HB*9m/", "com.fasterxml.jackson.databind.ObjectReader", (File) mockFile0);
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(file0);
assertFalse(mockFile0.isFile());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals("/experiment/*Fh", mockFile0.getParent());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.exists());
assertEquals("w3V;p,Z1j|", mockFile0.getName());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.isDirectory());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment/*Fh/w3V;p,Z1j|", mockFile0.toString());
assertEquals("0com.fasterxml.jackson.databind.ObjectReader", file0.getName());
assertEquals("/experiment/*Fh/w3V;p,Z1j|/+2|{,<(}{i>HB*9m/0com.fasterxml.jackson.databind.ObjectReader", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.length());
assertEquals("/experiment/*Fh/w3V;p,Z1j|/+2|{,<(}{i>HB*9m", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertNotSame(mockFile0, file0);
assertNotSame(file0, mockFile0);
MappingIterator<DOMDeserializer.NodeDeserializer> mappingIterator0 = objectReader1.readValues(file0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(mockFile0.equals((Object)file0));
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mockFile0.isFile());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals("/experiment/*Fh", mockFile0.getParent());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.exists());
assertEquals("w3V;p,Z1j|", mockFile0.getName());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.isDirectory());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment/*Fh/w3V;p,Z1j|", mockFile0.toString());
assertEquals("0com.fasterxml.jackson.databind.ObjectReader", file0.getName());
assertEquals("/experiment/*Fh/w3V;p,Z1j|/+2|{,<(}{i>HB*9m/0com.fasterxml.jackson.databind.ObjectReader", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.length());
assertEquals("/experiment/*Fh/w3V;p,Z1j|/+2|{,<(}{i>HB*9m", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertNotSame(objectReader1, objectReader0);
assertNotSame(mockFile0, file0);
assertNotSame(file0, mockFile0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
assertEquals(2, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
FormatFeature[] formatFeatureArray0 = new FormatFeature[4];
JsonWriteFeature jsonWriteFeature0 = JsonWriteFeature.ESCAPE_NON_ASCII;
assertEquals(JsonWriteFeature.ESCAPE_NON_ASCII, jsonWriteFeature0);
assertEquals(JsonGenerator.Feature.ESCAPE_NON_ASCII, jsonWriteFeature0.mappedFeature());
assertEquals(3, jsonWriteFeature0.collectDefaults());
assertEquals(4, jsonWriteFeature0.getMask());
assertFalse(jsonWriteFeature0.enabledByDefault());
formatFeatureArray0[0] = (FormatFeature) jsonWriteFeature0;
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_TRAILING_COMMA;
assertEquals(JsonReadFeature.ALLOW_TRAILING_COMMA, jsonReadFeature0);
assertEquals(0, jsonReadFeature0.collectDefaults());
assertEquals(512, jsonReadFeature0.getMask());
assertEquals(JsonParser.Feature.ALLOW_TRAILING_COMMA, jsonReadFeature0.mappedFeature());
assertFalse(jsonReadFeature0.enabledByDefault());
formatFeatureArray0[1] = (FormatFeature) jsonReadFeature0;
JsonReadFeature jsonReadFeature1 = JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature1);
assertFalse(jsonReadFeature1.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature1.enabledByDefault());
assertEquals(0, jsonReadFeature1.collectDefaults());
assertEquals(128, jsonReadFeature1.getMask());
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature1.mappedFeature());
assertNotSame(jsonReadFeature1, jsonReadFeature0);
formatFeatureArray0[2] = (FormatFeature) jsonReadFeature1;
JsonReadFeature jsonReadFeature2 = JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature2);
assertFalse(jsonReadFeature2.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature2.enabledByDefault());
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature2.mappedFeature());
assertEquals(0, jsonReadFeature2.collectDefaults());
assertEquals(128, jsonReadFeature2.getMask());
assertNotSame(jsonReadFeature2, jsonReadFeature0);
assertSame(jsonReadFeature2, jsonReadFeature1);
formatFeatureArray0[3] = (FormatFeature) jsonReadFeature2;
ObjectReader objectReader2 = objectReader1.withFeatures(formatFeatureArray0);
assertEquals(4, formatFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders0.withMaxInputLookahead(64);
assertEquals(2, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertSame(dataFormatReaders0, dataFormatReaders2);
assertSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
try {
objectReader0.readValues(byteArray0);
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: (byte[])\"\u0000\u0000\u0000\u0000\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test025() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
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);
Integer integer0 = Integer.valueOf((-391));
assertEquals((-391), (int)integer0);
assertNotNull(integer0);
ObjectReader objectReader1 = objectReader0.withValueToUpdate(integer0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withRootName("M)dl;+~");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator("*");
assertNotNull(jsonFactory1);
assertEquals("*", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("*", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonParser_Feature0);
assertNotNull(jsonFactory2);
assertEquals("*", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("*", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertEquals("*", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
LongNode longNode0 = new LongNode((-1002L));
assertNotNull(longNode0);
assertEquals((-1002.0), longNode0.doubleValue(), 0.01);
assertEquals((short) (-1002), longNode0.shortValue());
assertFalse(longNode0.isFloatingPointNumber());
assertFalse(longNode0.isFloat());
assertEquals((-1002L), longNode0.longValue());
assertEquals((-1002.0F), longNode0.floatValue(), 0.01F);
assertEquals((-1002), longNode0.intValue());
assertFalse(longNode0.booleanValue());
assertTrue(longNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.LONG, longNode0.numberType());
assertFalse(longNode0.isMissingNode());
assertFalse(longNode0.isBigInteger());
assertFalse(longNode0.isInt());
assertFalse(longNode0.isNaN());
assertEquals(0, longNode0.size());
assertFalse(longNode0.isDouble());
assertTrue(longNode0.isEmpty());
assertEquals(JsonToken.VALUE_NUMBER_INT, longNode0.asToken());
assertEquals(JsonNodeType.NUMBER, longNode0.getNodeType());
assertFalse(longNode0.isArray());
assertFalse(longNode0.isBigDecimal());
assertFalse(longNode0.isObject());
assertTrue(longNode0.canConvertToLong());
assertTrue(longNode0.isIntegralNumber());
assertNull(longNode0.textValue());
assertTrue(longNode0.isLong());
assertFalse(longNode0.isShort());
Integer integer1 = objectReader1.readValue((JsonNode) longNode0);
assertEquals((-391), (int)integer1);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertNotNull(integer1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals((-1002.0), longNode0.doubleValue(), 0.01);
assertEquals((short) (-1002), longNode0.shortValue());
assertFalse(longNode0.isFloatingPointNumber());
assertFalse(longNode0.isFloat());
assertEquals((-1002L), longNode0.longValue());
assertEquals((-1002.0F), longNode0.floatValue(), 0.01F);
assertEquals((-1002), longNode0.intValue());
assertFalse(longNode0.booleanValue());
assertTrue(longNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.LONG, longNode0.numberType());
assertFalse(longNode0.isMissingNode());
assertFalse(longNode0.isBigInteger());
assertFalse(longNode0.isInt());
assertFalse(longNode0.isNaN());
assertEquals(0, longNode0.size());
assertFalse(longNode0.isDouble());
assertTrue(longNode0.isEmpty());
assertEquals(JsonToken.VALUE_NUMBER_INT, longNode0.asToken());
assertEquals(JsonNodeType.NUMBER, longNode0.getNodeType());
assertFalse(longNode0.isArray());
assertFalse(longNode0.isBigDecimal());
assertFalse(longNode0.isObject());
assertTrue(longNode0.canConvertToLong());
assertTrue(longNode0.isIntegralNumber());
assertNull(longNode0.textValue());
assertTrue(longNode0.isLong());
assertFalse(longNode0.isShort());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
}
@Test(timeout = 4000)
public void test026() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
LinkedHashSet<IntNode> linkedHashSet0 = new LinkedHashSet<IntNode>();
assertNotNull(linkedHashSet0);
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) linkedHashSet0, (Object) linkedHashSet0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(objectMapper0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory(objectReader1);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator("No value type configured for ObjectReader");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("No value type configured for ObjectReader", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("No value type configured for ObjectReader", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory1.getFormatName());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectReader objectReader2 = objectReader1.with(jsonFactory1);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("No value type configured for ObjectReader", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("No value type configured for ObjectReader", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory1.getFormatName());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
// Undeclared exception!
try {
objectReader1.readValues((Reader) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// Could not initialize class com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.deser.DeserializerCache", e);
}
}
@Test(timeout = 4000)
public void test027() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
double double0 = objectNode0.asDouble();
assertEquals(0.0, double0, 0.01);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(0, objectNode1.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isIntegralNumber());
assertNull(objectNode1.numberType());
assertTrue(objectNode1.isEmpty());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0, 33);
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertNull(arrayNode0.numberType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
JsonParser jsonParser0 = arrayNode0.traverse();
assertNotNull(jsonParser0);
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertNull(arrayNode0.numberType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
DeserializationContext deserializationContext0 = objectMapper0.getDeserializationContext();
assertNotNull(deserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader[] objectReaderArray0 = new ObjectReader[8];
objectReaderArray0[0] = objectReader1;
objectReaderArray0[1] = objectReader1;
objectReaderArray0[2] = objectReader0;
Object object0 = new Object();
assertNotNull(object0);
ObjectReader objectReader2 = objectMapper0.readerForUpdating(object0);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
objectReaderArray0[3] = objectReader2;
objectReaderArray0[4] = objectReader1;
objectReaderArray0[5] = objectReader1;
objectReaderArray0[6] = objectReader0;
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonParser_Feature0, false);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.STRICT_DUPLICATE_DETECTION;
JsonFactory jsonFactory3 = jsonFactory2.disable(jsonGenerator_Feature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertNotNull(jsonFactory3);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
JsonFactory jsonFactory4 = jsonFactory3.enable(jsonParser_Feature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertNotNull(jsonFactory4);
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertTrue(jsonFactory4.canUseCharArrays());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertEquals("JSON", jsonFactory4.getFormatName());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory4);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory0);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory4.createParser((Reader) pipedReader0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
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());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertTrue(jsonFactory4.canUseCharArrays());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertEquals("JSON", jsonFactory4.getFormatName());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory4);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory0);
try {
objectReader2._initForReading(deserializationContext0, readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test028() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader((JsonNodeFactory) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES;
ObjectReader objectReader1 = objectReader0.without(deserializationFeature0);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "$EtA#nGWt7");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ObjectReader objectReader2 = objectReader0.with(contextAttributes0);
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader0, objectReader2);
assertSame(objectReader2, objectReader1);
assertSame(objectReader2, objectReader0);
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader0, objectReader2);
assertSame(objectReader1, objectReader0);
assertSame(objectReader1, objectReader2);
Class<LongNode> class0 = LongNode.class;
ObjectReader objectReader3 = objectReader1.forType(class0);
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader2));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader3);
assertSame(objectReader0, objectReader1);
assertSame(objectReader0, objectReader2);
assertSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader3);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader2);
SimpleKeyDeserializers simpleKeyDeserializers0 = new SimpleKeyDeserializers();
assertNotNull(simpleKeyDeserializers0);
// Undeclared exception!
try {
objectReader1.readTree("");
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test029() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
NullNode nullNode0 = NullNode.getInstance();
assertNotNull(nullNode0);
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloat());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.isBigInteger());
assertNull(nullNode0.textValue());
assertEquals("null", nullNode0.asText());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isShort());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertFalse(nullNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isIntegralNumber());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isDouble());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isArray());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
BigInteger bigInteger0 = BigInteger.TEN;
assertNotNull(bigInteger0);
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
MissingNode missingNode0 = objectReader0.readValue((JsonNode) nullNode0);
assertNull(missingNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertFalse(nullNode0.isFloat());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.isBigInteger());
assertNull(nullNode0.textValue());
assertEquals("null", nullNode0.asText());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isShort());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertFalse(nullNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isIntegralNumber());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isDouble());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isArray());
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte) (-89);
byteArray0[1] = (byte) (-85);
byteArray0[2] = (byte)63;
byteArray0[3] = (byte) (-58);
byteArray0[4] = (byte) (-11);
byteArray0[5] = (byte)2;
byteArray0[6] = (byte)1;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 3, 705);
assertArrayEquals(new byte[] {(byte) (-89), (byte) (-85), (byte)63, (byte) (-58), (byte) (-11), (byte)2, (byte)1}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(4, byteArrayInputStream0.available());
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-89), (byte) (-85), (byte)63, (byte) (-58), (byte) (-11), (byte)2, (byte)1}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(bufferedInputStream0);
assertEquals(4, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(bufferedInputStream0);
assertArrayEquals(new byte[] {(byte) (-89), (byte) (-85), (byte)63, (byte) (-58), (byte) (-11), (byte)2, (byte)1}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(4, byteArrayInputStream0.available());
try {
objectReader0.readValue((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Invalid UTF-8 middle byte 0xf5
// at [Source: (DataInputStream); line: 1, column: -1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test030() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals("", missingNode0.asText());
assertEquals(0, missingNode0.size());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isDouble());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isArray());
assertNull(missingNode0.textValue());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isFloat());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
Class<CollectionType> class1 = CollectionType.class;
SimpleType simpleType1 = SimpleType.constructUnsafe(class1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertFalse(simpleType1.isEnumType());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertTrue(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.hasValueHandler());
assertNotSame(simpleType1, simpleType0);
Object object0 = new Object();
assertNotNull(object0);
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer(simpleType1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.isEnumType());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertTrue(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.hasValueHandler());
assertEquals(AccessPattern.DYNAMIC, jsonDeserializer0.getEmptyAccessPattern());
assertEquals(AccessPattern.ALWAYS_NULL, jsonDeserializer0.getNullAccessPattern());
assertTrue(jsonDeserializer0.isCachable());
assertNotSame(simpleType1, simpleType0);
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);
ObjectReader objectReader1 = objectReader0.withValueToUpdate((Object) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, class0, true);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
assertSame(iOContext1, iOContext0);
assertSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 968, pipedReader0, objectMapper0, charsToNameCanonicalizer0, charArray0, (-1269), (-1068), true);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(968, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideFormatFeatures(1, (-2098677199));
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(968, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(968, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
assertSame(iOContext1, iOContext0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext0, iOContext1);
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory((DeserializerFactoryConfig) null);
assertNotNull(beanDeserializerFactory0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
// Undeclared exception!
try {
beanDeserializerFactory0.withDeserializerModifier(beanDeserializerModifier0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test031() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
NullNode nullNode0 = NullNode.getInstance();
assertNotNull(nullNode0);
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isBigDecimal());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.isBigInteger());
assertFalse(nullNode0.isShort());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isMissingNode());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isFloat());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertEquals("null", nullNode0.asText());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
BigInteger bigInteger0 = BigInteger.TEN;
assertNotNull(bigInteger0);
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
MissingNode missingNode0 = objectReader0.readValue((JsonNode) nullNode0);
assertNull(missingNode0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isBigDecimal());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isInt());
assertFalse(nullNode0.isBigInteger());
assertFalse(nullNode0.isShort());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isMissingNode());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isFloat());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertEquals("null", nullNode0.asText());
try {
objectReader0.readTree("JSON");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'JSON': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"JSON\"; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test032() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[3];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(3, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.withAttribute(objectMapper0, objectReader0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test033() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory2);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonFactory jsonFactory3 = jsonFactory1.enable(jsonParser_Feature0);
assertNotNull(jsonFactory3);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8195, jsonFactory3.getParserFeatures());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
char[] charArray0 = new char[3];
charArray0[0] = '{';
charArray0[1] = '3';
charArray0[2] = '{';
Short short0 = new Short((short)9);
assertEquals((short)9, (short)short0);
assertNotNull(short0);
LongNode longNode0 = LongNode.valueOf((-1513L));
assertNotNull(longNode0);
assertTrue(longNode0.isLong());
assertFalse(longNode0.isBigInteger());
assertEquals((-1513.0F), longNode0.floatValue(), 0.01F);
assertFalse(longNode0.isFloat());
assertTrue(longNode0.canConvertToInt());
assertFalse(longNode0.isBigDecimal());
assertTrue(longNode0.isIntegralNumber());
assertEquals(JsonParser.NumberType.LONG, longNode0.numberType());
assertFalse(longNode0.isShort());
assertTrue(longNode0.canConvertToLong());
assertFalse(longNode0.booleanValue());
assertEquals(0, longNode0.size());
assertEquals(JsonNodeType.NUMBER, longNode0.getNodeType());
assertFalse(longNode0.isArray());
assertEquals((-1513), longNode0.intValue());
assertEquals((short) (-1513), longNode0.shortValue());
assertEquals(JsonToken.VALUE_NUMBER_INT, longNode0.asToken());
assertNull(longNode0.textValue());
assertEquals((-1513L), longNode0.longValue());
assertFalse(longNode0.isNaN());
assertFalse(longNode0.isObject());
assertFalse(longNode0.isInt());
assertFalse(longNode0.isMissingNode());
assertFalse(longNode0.isFloatingPointNumber());
assertEquals((-1513.0), longNode0.doubleValue(), 0.01);
assertFalse(longNode0.isDouble());
assertTrue(longNode0.isEmpty());
// Undeclared exception!
try {
objectReader2.readValue((JsonNode) longNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test034() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getPort());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
IntNode intNode0 = new IntNode(0);
assertNotNull(intNode0);
assertFalse(intNode0.isFloatingPointNumber());
assertEquals((short)0, intNode0.shortValue());
assertFalse(intNode0.isShort());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isBigDecimal());
assertTrue(intNode0.canConvertToInt());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertEquals(0.0F, intNode0.floatValue(), 0.01F);
assertTrue(intNode0.canConvertToLong());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isObject());
assertFalse(intNode0.isFloat());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isLong());
assertEquals(0, intNode0.size());
assertEquals(0, intNode0.intValue());
assertFalse(intNode0.isNaN());
assertNull(intNode0.textValue());
assertFalse(intNode0.isMissingNode());
assertEquals(0L, intNode0.longValue());
assertEquals(0.0, intNode0.doubleValue(), 0.01);
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isInt());
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
JsonNode jsonNode0 = concurrentHashMap0.put("0LS^>iDaXmbY>", intNode0);
assertNull(jsonNode0);
assertFalse(intNode0.isFloatingPointNumber());
assertEquals((short)0, intNode0.shortValue());
assertFalse(intNode0.isShort());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isBigDecimal());
assertTrue(intNode0.canConvertToInt());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertEquals(0.0F, intNode0.floatValue(), 0.01F);
assertTrue(intNode0.canConvertToLong());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isObject());
assertFalse(intNode0.isFloat());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isLong());
assertEquals(0, intNode0.size());
assertEquals(0, intNode0.intValue());
assertFalse(intNode0.isNaN());
assertNull(intNode0.textValue());
assertFalse(intNode0.isMissingNode());
assertEquals(0L, intNode0.longValue());
assertEquals(0.0, intNode0.doubleValue(), 0.01);
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isInt());
assertFalse(concurrentHashMap0.isEmpty());
ConcurrentHashMap<String, JsonNode> concurrentHashMap1 = new ConcurrentHashMap<String, JsonNode>();
assertFalse(concurrentHashMap1.equals((Object)concurrentHashMap0));
assertNotNull(concurrentHashMap1);
assertTrue(concurrentHashMap1.isEmpty());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertFalse(concurrentHashMap0.equals((Object)concurrentHashMap1));
assertNotNull(objectNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertFalse(concurrentHashMap0.equals((Object)concurrentHashMap1));
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode1.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isFloat());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isIntegralNumber());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isDouble());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isBigDecimal());
assertNull(objectNode1.numberType());
assertNotSame(concurrentHashMap0, concurrentHashMap1);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
Boolean boolean0 = new Boolean("0LS^>iDaXmbY>");
assertFalse(boolean0);
assertNotNull(boolean0);
ObjectNode objectNode2 = objectNode0.put("{%\"z k<uGMSqT", "G");
assertFalse(concurrentHashMap0.equals((Object)concurrentHashMap1));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertNotNull(objectNode2);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isMissingNode());
assertEquals(2, objectNode0.size());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isMissingNode());
assertEquals(2, objectNode2.size());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isFloat());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isLong());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.booleanValue());
assertNotSame(concurrentHashMap0, concurrentHashMap1);
assertSame(objectNode0, objectNode2);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader1.treeToValue((TreeNode) objectNode2, class0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test035() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
PlaceholderForType placeholderForType0 = new PlaceholderForType(2330);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.isEnumType());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isArrayType());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
JavaType javaType0 = placeholderForType0.getContentType();
assertNull(javaType0);
assertFalse(placeholderForType0.isEnumType());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isArrayType());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
// Undeclared exception!
try {
objectReader1.forType((JavaType) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test036() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "0LS^>iDaXmbY>");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<TextNode> class0 = TextNode.class;
ObjectReader objectReader1 = objectReader0.withView(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.forType(class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
Locale locale0 = Locale.KOREA;
assertNotNull(locale0);
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
ObjectReader objectReader3 = objectReader1.with(locale0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory(objectReader1);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectReader3);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonGenerator_Feature0, false);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonParser_Feature0, false);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)104;
byteArray0[1] = (byte)32;
byteArray0[2] = (byte)35;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)38;
byteArray0[5] = (byte) (-105);
byteArray0[6] = (byte) (-95);
byteArray0[7] = (byte)2;
byteArray0[8] = (byte) (-89);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory3.createParser(byteArray0);
assertArrayEquals(new byte[] {(byte)104, (byte)32, (byte)35, (byte)0, (byte)38, (byte) (-105), (byte) (-95), (byte)2, (byte) (-89)}, byteArray0);
assertEquals(9, byteArray0.length);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(uTF8StreamJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertEquals("ko_KR", locale0.toString());
assertEquals("KR", locale0.getCountry());
assertEquals("ko", locale0.getLanguage());
assertEquals("KOR", locale0.getISO3Country());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
Class<DecimalNode> class1 = DecimalNode.class;
try {
objectReader1.readValue((JsonParser) uTF8StreamJsonParser0, class1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'h': was expecting ('true', 'false' or 'null')
// at [Source: (byte[])\"h #\u0000&\uFFFD\uFFFD\u0002\uFFFD\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test037() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ArrayList<IntNode> arrayList0 = new ArrayList<IntNode>();
assertNotNull(arrayList0);
assertEquals(0, arrayList0.size());
assertTrue(arrayList0.isEmpty());
Iterator<IntNode> iterator0 = arrayList0.iterator();
assertNotNull(iterator0);
assertEquals(0, arrayList0.size());
assertTrue(arrayList0.isEmpty());
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isLong());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isFloat());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isBigInteger());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertEquals("", missingNode0.asText());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) arrayList0, (Object) missingNode0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, arrayList0.size());
assertTrue(arrayList0.isEmpty());
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isLong());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isFloat());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isBigInteger());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertEquals("", missingNode0.asText());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(missingNode0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isLong());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isFloat());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isBigInteger());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertEquals("", missingNode0.asText());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
ObjectReader objectReader2 = objectReader0.without(jsonParser_Feature0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
SimpleDeserializers simpleDeserializers0 = new SimpleDeserializers();
assertNotNull(simpleDeserializers0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAdditionalDeserializers(simpleDeserializers0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
// Undeclared exception!
try {
objectReader1._findRootDeserializer(defaultDeserializationContext_Impl0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DeserializerCache", e);
}
}
@Test(timeout = 4000)
public void test038() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
assertNotNull(objectNode0);
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
Class<MapLikeType> class0 = MapLikeType.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.readValue((JsonNode) objectNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test039() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isFloat());
assertNull(objectNode0.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
double double0 = objectNode0.asDouble();
assertEquals(0.0, double0, 0.01);
assertTrue(concurrentHashMap0.isEmpty());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isFloat());
assertNull(objectNode0.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isFloat());
assertNull(objectNode0.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isBigDecimal());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isFloat());
assertEquals(0, objectNode1.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isDouble());
assertTrue(objectNode1.isEmpty());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_TRAILING_TOKENS;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[8];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
deserializationFeatureArray0[7] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
assertEquals(8, deserializationFeatureArray0.length);
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(deserializationFeature0, deserializationFeature1);
Class<ObjectNode> class0 = ObjectNode.class;
ObjectNode objectNode2 = objectReader0.treeToValue((TreeNode) objectNode0, class0);
assertEquals(8, deserializationFeatureArray0.length);
assertTrue(objectNode0.equals((Object)objectNode1));
assertTrue(objectNode2.equals((Object)objectNode1));
assertTrue(objectNode2.equals((Object)objectNode0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectNode2);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isFloat());
assertNull(objectNode0.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isArray());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertEquals(0, objectNode2.size());
assertTrue(objectNode2.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertTrue(objectNode2.isEmpty());
assertFalse(objectNode2.booleanValue());
assertNull(objectNode2.numberType());
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode2, objectNode1);
assertNotSame(objectNode2, objectNode0);
assertNotSame(deserializationFeature0, deserializationFeature1);
ObjectReader objectReader1 = objectMapper0.readerFor((JavaType) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
try {
objectReader1.readValues("hDK1~G}Ba");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'hDK1': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"hDK1~G}Ba\"; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test040() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("{%\"z k<uGMqT");
assertNotNull(mockFile0);
// Undeclared exception!
try {
objectReader1.withRootName("{%\"z k<uGMqT");
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test041() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertEquals(0, objectNode0.size());
ObjectNode objectNode1 = objectNode0.put("3{g3>E8>kjHLIMU(ux", 0.0F);
assertNotNull(objectNode1);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isShort());
assertEquals(1, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
JsonNode jsonNode0 = objectNode1.findValue(")");
assertNull(jsonNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isShort());
assertEquals(1, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
Class<ObjectNode> class0 = ObjectNode.class;
ObjectNode objectNode2 = objectNode0.putObject(")");
assertFalse(objectNode2.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode0));
assertNotNull(objectNode2);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isFloat());
assertEquals(0, objectNode2.size());
assertFalse(objectNode2.isBigDecimal());
assertTrue(objectNode2.isEmpty());
assertFalse(objectNode2.booleanValue());
assertNull(objectNode2.numberType());
assertSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode2, objectNode1);
assertNotSame(objectNode2, objectNode0);
JsonParser jsonParser0 = objectMapper0.treeAsTokens(objectNode1);
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode1.equals((Object)objectNode2));
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isBigInteger());
assertEquals(2, objectNode1.size());
assertFalse(objectNode1.isShort());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertEquals(0, jsonParser0.currentTokenId());
assertNull(jsonParser0.getCurrentToken());
assertFalse(jsonParser0.isClosed());
assertNull(jsonParser0.currentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode0);
assertNotSame(objectNode1, objectNode2);
TypeBindings typeBindings0 = TypeBindings.emptyBindings();
assertNotNull(typeBindings0);
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
Class<SimpleType> class1 = SimpleType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class1);
assertNotNull(simpleType0);
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
MapLikeType mapLikeType0 = MapLikeType.upgradeFrom(simpleType0, simpleType0, simpleType0);
assertNotNull(mapLikeType0);
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
JavaType[] javaTypeArray0 = new JavaType[0];
ReferenceType referenceType0 = ReferenceType.construct((Class<?>) class0, typeBindings0, (JavaType) mapLikeType0, javaTypeArray0, (JavaType) mapLikeType0);
assertEquals(0, javaTypeArray0.length);
assertNotNull(referenceType0);
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.hasContentType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isAbstract());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isPrimitive());
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)115;
byteArray0[1] = (byte)54;
BinaryNode binaryNode0 = new BinaryNode(byteArray0);
assertArrayEquals(new byte[] {(byte)115, (byte)54}, byteArray0);
assertEquals(2, byteArray0.length);
assertNotNull(binaryNode0);
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isBigDecimal());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isLong());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isDouble());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isFloat());
ReferenceType referenceType1 = referenceType0.withValueHandler(binaryNode0);
assertArrayEquals(new byte[] {(byte)115, (byte)54}, byteArray0);
assertEquals(2, byteArray0.length);
assertEquals(0, javaTypeArray0.length);
assertTrue(referenceType1.equals((Object)referenceType0));
assertNotNull(referenceType1);
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isBigDecimal());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isLong());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isDouble());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertTrue(referenceType1.isConcrete());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.hasValueHandler());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.hasHandlers());
assertFalse(referenceType1.isFinal());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.hasContentType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isAbstract());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isPrimitive());
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType0, referenceType1);
ReferenceType referenceType2 = referenceType1.withStaticTyping();
assertArrayEquals(new byte[] {(byte)115, (byte)54}, byteArray0);
assertEquals(2, byteArray0.length);
assertEquals(0, javaTypeArray0.length);
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType1));
assertNotNull(referenceType2);
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isBigDecimal());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isLong());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isDouble());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertTrue(referenceType1.isConcrete());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.hasValueHandler());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.hasHandlers());
assertFalse(referenceType1.isFinal());
assertTrue(referenceType2.useStaticType());
assertTrue(referenceType2.hasValueHandler());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.isAnchorType());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isCollectionLikeType());
assertTrue(referenceType2.hasHandlers());
assertFalse(referenceType2.isFinal());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.isArrayType());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isAbstract());
assertTrue(referenceType2.isReferenceType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.hasContentType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isAbstract());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isPrimitive());
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType1);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
ReferenceType referenceType3 = referenceType2.withContentValueHandler(class1);
assertArrayEquals(new byte[] {(byte)115, (byte)54}, byteArray0);
assertEquals(2, byteArray0.length);
assertEquals(0, javaTypeArray0.length);
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType3.equals((Object)referenceType2));
assertTrue(referenceType3.equals((Object)referenceType1));
assertTrue(referenceType3.equals((Object)referenceType0));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType2));
assertNotNull(referenceType3);
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isBigDecimal());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isLong());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isDouble());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertTrue(referenceType1.isConcrete());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.hasValueHandler());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.hasHandlers());
assertFalse(referenceType1.isFinal());
assertTrue(referenceType2.useStaticType());
assertTrue(referenceType2.hasValueHandler());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.isAnchorType());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isCollectionLikeType());
assertTrue(referenceType2.hasHandlers());
assertFalse(referenceType2.isFinal());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.isArrayType());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isAbstract());
assertTrue(referenceType2.isReferenceType());
assertEquals(0, referenceType2.containedTypeCount());
assertFalse(referenceType3.isPrimitive());
assertFalse(referenceType3.isArrayType());
assertFalse(referenceType3.isAnchorType());
assertFalse(referenceType3.isMapLikeType());
assertFalse(referenceType3.isInterface());
assertTrue(referenceType3.hasHandlers());
assertFalse(referenceType3.isJavaLangObject());
assertTrue(referenceType3.isConcrete());
assertTrue(referenceType3.isReferenceType());
assertEquals(0, referenceType3.containedTypeCount());
assertFalse(referenceType3.isContainerType());
assertTrue(referenceType3.hasValueHandler());
assertFalse(referenceType3.isEnumType());
assertFalse(referenceType3.isAbstract());
assertTrue(referenceType3.useStaticType());
assertFalse(referenceType3.isFinal());
assertTrue(referenceType3.hasContentType());
assertFalse(referenceType3.isCollectionLikeType());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.hasContentType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isAbstract());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isPrimitive());
assertNotSame(referenceType1, referenceType3);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType1);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType3);
assertNotSame(referenceType3, referenceType1);
assertNotSame(referenceType3, referenceType0);
assertNotSame(referenceType3, referenceType2);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType3);
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isInt());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.booleanValue());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isFloat());
assertTrue(missingNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertNull(missingNode0.textValue());
ReferenceType referenceType4 = (ReferenceType)referenceType3.withTypeHandler(missingNode0);
assertArrayEquals(new byte[] {(byte)115, (byte)54}, byteArray0);
assertEquals(2, byteArray0.length);
assertEquals(0, javaTypeArray0.length);
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType3));
assertTrue(referenceType0.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType3));
assertTrue(referenceType2.equals((Object)referenceType3));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType3.equals((Object)referenceType2));
assertTrue(referenceType3.equals((Object)referenceType1));
assertTrue(referenceType3.equals((Object)referenceType0));
assertTrue(referenceType4.equals((Object)referenceType2));
assertTrue(referenceType4.equals((Object)referenceType0));
assertTrue(referenceType4.equals((Object)referenceType3));
assertTrue(referenceType4.equals((Object)referenceType1));
assertNotNull(referenceType4);
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isBigDecimal());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isLong());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isDouble());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertTrue(referenceType1.isConcrete());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.useStaticType());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.hasValueHandler());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isJavaLangObject());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.hasHandlers());
assertFalse(referenceType1.isFinal());
assertTrue(referenceType2.useStaticType());
assertTrue(referenceType2.hasValueHandler());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.isAnchorType());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isCollectionLikeType());
assertTrue(referenceType2.hasHandlers());
assertFalse(referenceType2.isFinal());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.isArrayType());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isAbstract());
assertTrue(referenceType2.isReferenceType());
assertEquals(0, referenceType2.containedTypeCount());
assertFalse(referenceType3.isPrimitive());
assertFalse(referenceType3.isArrayType());
assertFalse(referenceType3.isAnchorType());
assertFalse(referenceType3.isMapLikeType());
assertFalse(referenceType3.isInterface());
assertTrue(referenceType3.hasHandlers());
assertFalse(referenceType3.isJavaLangObject());
assertTrue(referenceType3.isConcrete());
assertTrue(referenceType3.isReferenceType());
assertEquals(0, referenceType3.containedTypeCount());
assertFalse(referenceType3.isContainerType());
assertTrue(referenceType3.hasValueHandler());
assertFalse(referenceType3.isEnumType());
assertFalse(referenceType3.isAbstract());
assertTrue(referenceType3.useStaticType());
assertFalse(referenceType3.isFinal());
assertTrue(referenceType3.hasContentType());
assertFalse(referenceType3.isCollectionLikeType());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isInt());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.booleanValue());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isFloat());
assertTrue(missingNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertNull(missingNode0.textValue());
assertFalse(referenceType4.isMapLikeType());
assertFalse(referenceType4.isPrimitive());
assertFalse(referenceType4.isAnchorType());
assertTrue(referenceType4.useStaticType());
assertFalse(referenceType4.isInterface());
assertEquals(0, referenceType4.containedTypeCount());
assertFalse(referenceType4.isArrayType());
assertTrue(referenceType4.isReferenceType());
assertFalse(referenceType4.isContainerType());
assertTrue(referenceType4.hasValueHandler());
assertFalse(referenceType4.isEnumType());
assertTrue(referenceType4.isConcrete());
assertFalse(referenceType4.isAbstract());
assertFalse(referenceType4.isCollectionLikeType());
assertFalse(referenceType4.isFinal());
assertFalse(referenceType4.isJavaLangObject());
assertTrue(referenceType4.hasHandlers());
assertTrue(referenceType4.hasContentType());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.useStaticType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.hasHandlers());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.hasContentType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isAbstract());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isPrimitive());
assertNotSame(referenceType0, referenceType4);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType3);
assertNotSame(referenceType1, referenceType3);
assertNotSame(referenceType1, referenceType4);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType1);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType3);
assertNotSame(referenceType2, referenceType4);
assertNotSame(referenceType3, referenceType4);
assertNotSame(referenceType3, referenceType1);
assertNotSame(referenceType3, referenceType0);
assertNotSame(referenceType3, referenceType2);
assertNotSame(referenceType4, referenceType1);
assertNotSame(referenceType4, referenceType2);
assertNotSame(referenceType4, referenceType0);
assertNotSame(referenceType4, referenceType3);
// Undeclared exception!
try {
objectReader0.readValues(jsonParser0, (JavaType) referenceType4);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// java.lang.Class cannot be cast to com.fasterxml.jackson.databind.JsonDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test042() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
BeanProperty.Bogus beanProperty_Bogus0 = new BeanProperty.Bogus();
assertNotNull(beanProperty_Bogus0);
assertFalse(beanProperty_Bogus0.isRequired());
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(beanProperty_Bogus0.isVirtual());
JavaType javaType0 = beanProperty_Bogus0.getType();
assertNotNull(javaType0);
assertFalse(beanProperty_Bogus0.isRequired());
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.useStaticType());
assertTrue(javaType0.isConcrete());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.isAbstract());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isCollectionLikeType());
ObjectReader objectReader2 = objectReader1.forType(javaType0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(beanProperty_Bogus0.isRequired());
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.useStaticType());
assertTrue(javaType0.isConcrete());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.isAbstract());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isCollectionLikeType());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
}
@Test(timeout = 4000)
public void test043() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
double double0 = objectNode0.asDouble();
assertEquals(0.0, double0, 0.01);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertEquals("", objectNode1.asText());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.booleanValue());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isBigDecimal());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertEquals(0, objectNode1.size());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
Class<ObjectNode> class0 = ObjectNode.class;
ObjectNode objectNode2 = objectNode0.put("0LS^>iDaXmbY>", "Y[ >");
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertNotNull(objectNode2);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals("", objectNode2.asText());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isLong());
assertEquals(1, objectNode2.size());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isBigDecimal());
assertNull(objectNode2.numberType());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
ArrayNode arrayNode0 = objectNode2.putArray("\"W{XtF:]#cIc~Q^<bs#");
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertNotNull(arrayNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals("", objectNode2.asText());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isLong());
assertEquals(2, objectNode2.size());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isBigDecimal());
assertNull(objectNode2.numberType());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isFloatingPointNumber());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isIntegralNumber());
assertTrue(arrayNode0.isEmpty());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
JsonParser jsonParser0 = arrayNode0.traverse();
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertNotNull(jsonParser0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals("", objectNode2.asText());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isLong());
assertEquals(2, objectNode2.size());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isBigDecimal());
assertNull(objectNode2.numberType());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isFloatingPointNumber());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isIntegralNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getLastClearedToken());
assertNull(jsonParser0.getCurrentToken());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.currentTokenId());
assertEquals(0, jsonParser0.getTextOffset());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
DeserializationContext deserializationContext0 = objectMapper0.getDeserializationContext();
assertNotNull(deserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<List> class1 = List.class;
CollectionType collectionType0 = typeFactory0.constructCollectionType(class1, class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(collectionType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
CollectionType collectionType1 = collectionType0.withStaticTyping();
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(collectionType1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isAbstract());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.hasHandlers());
assertNotSame(collectionType0, collectionType1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(objectReader1, objectReader0);
Class<BooleanNode> class2 = BooleanNode.class;
TypeBindings typeBindings0 = TypeBindings.create(class2, (JavaType[]) null);
assertNotNull(typeBindings0);
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
ReferenceType referenceType0 = ReferenceType.construct((Class<?>) class2, typeBindings0, (JavaType) collectionType1, (JavaType[]) null, (JavaType) collectionType0);
assertTrue(collectionType0.equals((Object)collectionType1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(referenceType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isAbstract());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.hasHandlers());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.useStaticType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isFinal());
assertNotSame(collectionType0, collectionType1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(objectReader1, objectReader0);
ReferenceType referenceType1 = referenceType0.withContentValueHandler(objectNode0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(referenceType1.equals((Object)referenceType0));
assertNotNull(referenceType1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isAbstract());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.hasHandlers());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.useStaticType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isFinal());
assertFalse(concurrentHashMap0.isEmpty());
assertTrue(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.hasHandlers());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAnchorType());
assertEquals(0, referenceType1.containedTypeCount());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isReferenceType());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
IntNode intNode0 = IntNode.valueOf((-1913347673));
assertNotNull(intNode0);
assertFalse(intNode0.isLong());
assertFalse(intNode0.isMissingNode());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals((-1.91334771E9F), intNode0.floatValue(), 0.01F);
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.canConvertToInt());
assertEquals((-1.913347673E9), intNode0.doubleValue(), 0.01);
assertTrue(intNode0.isInt());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigInteger());
assertEquals((-1913347673L), intNode0.longValue());
assertEquals((short) (-24153), intNode0.shortValue());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isBigDecimal());
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isShort());
assertNull(intNode0.textValue());
assertEquals((-1913347673), intNode0.intValue());
ReferenceType referenceType2 = referenceType1.withContentTypeHandler(intNode0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertNotNull(referenceType2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isAbstract());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.hasHandlers());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.useStaticType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isFinal());
assertTrue(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.hasHandlers());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAnchorType());
assertEquals(0, referenceType1.containedTypeCount());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isReferenceType());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isMissingNode());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals((-1.91334771E9F), intNode0.floatValue(), 0.01F);
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.canConvertToInt());
assertEquals((-1.913347673E9), intNode0.doubleValue(), 0.01);
assertTrue(intNode0.isInt());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigInteger());
assertEquals((-1913347673L), intNode0.longValue());
assertEquals((short) (-24153), intNode0.shortValue());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isBigDecimal());
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isShort());
assertNull(intNode0.textValue());
assertEquals((-1913347673), intNode0.intValue());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAbstract());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isInterface());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.hasHandlers());
assertFalse(referenceType2.isFinal());
assertFalse(referenceType2.useStaticType());
assertFalse(referenceType2.isAnchorType());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isArrayType());
assertTrue(referenceType2.isReferenceType());
assertEquals(0, referenceType2.containedTypeCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
assertNotSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
CollectionLikeType collectionLikeType0 = collectionType1.withContentTypeHandler(referenceType2);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(collectionLikeType0.equals((Object)collectionType1));
assertTrue(collectionLikeType0.equals((Object)collectionType0));
assertNotNull(collectionLikeType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(2, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.isArrayType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.isJavaLangObject());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.isEnumType());
assertTrue(collectionType0.isCollectionLikeType());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isPrimitive());
assertFalse(collectionType1.isEnumType());
assertTrue(collectionType1.useStaticType());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.isAbstract());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isPrimitive());
assertFalse(collectionType1.isMapLikeType());
assertTrue(collectionType1.hasContentType());
assertFalse(collectionType1.isArrayType());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isJavaLangObject());
assertFalse(collectionType1.hasHandlers());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.useStaticType());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isAbstract());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isFinal());
assertTrue(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.hasHandlers());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAnchorType());
assertEquals(0, referenceType1.containedTypeCount());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isReferenceType());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isMissingNode());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals((-1.91334771E9F), intNode0.floatValue(), 0.01F);
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.canConvertToInt());
assertEquals((-1.913347673E9), intNode0.doubleValue(), 0.01);
assertTrue(intNode0.isInt());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigInteger());
assertEquals((-1913347673L), intNode0.longValue());
assertEquals((short) (-24153), intNode0.shortValue());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isBigDecimal());
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isShort());
assertNull(intNode0.textValue());
assertEquals((-1913347673), intNode0.intValue());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAbstract());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isInterface());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isEnumType());
assertFalse(referenceType2.hasHandlers());
assertFalse(referenceType2.isFinal());
assertFalse(referenceType2.useStaticType());
assertFalse(referenceType2.isAnchorType());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isArrayType());
assertTrue(referenceType2.isReferenceType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isEnumType());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertEquals(1, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isJavaLangObject());
assertTrue(collectionLikeType0.isContainerType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.hasContentType());
assertTrue(collectionLikeType0.isInterface());
assertTrue(collectionLikeType0.isAbstract());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertFalse(collectionLikeType0.hasValueHandler());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertNotSame(collectionType0, collectionLikeType0);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionLikeType0);
assertNotSame(collectionType1, collectionType0);
assertNotSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
assertNotSame(collectionLikeType0, collectionType0);
assertNotSame(collectionLikeType0, collectionType1);
// Undeclared exception!
try {
objectReader0._verifyNoTrailingTokens(jsonParser0, deserializationContext0, collectionLikeType0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test044() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte) (-102);
byteArray0[1] = (byte) (-89);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory0.createParser(byteArray0);
assertArrayEquals(new byte[] {(byte) (-102), (byte) (-89)}, byteArray0);
assertEquals(2, byteArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
Class<ObjectIdResolver> class0 = ObjectIdResolver.class;
CoreXMLDeserializers.Std coreXMLDeserializers_Std0 = new CoreXMLDeserializers.Std(class0, (byte) (-102));
assertNotNull(coreXMLDeserializers_Std0);
assertEquals(AccessPattern.ALWAYS_NULL, coreXMLDeserializers_Std0.getNullAccessPattern());
assertEquals(AccessPattern.CONSTANT, coreXMLDeserializers_Std0.getEmptyAccessPattern());
assertFalse(coreXMLDeserializers_Std0.isCachable());
JavaType javaType0 = coreXMLDeserializers_Std0.getValueType();
assertNull(javaType0);
assertEquals(AccessPattern.ALWAYS_NULL, coreXMLDeserializers_Std0.getNullAccessPattern());
assertEquals(AccessPattern.CONSTANT, coreXMLDeserializers_Std0.getEmptyAccessPattern());
assertFalse(coreXMLDeserializers_Std0.isCachable());
try {
objectReader0.readValue((JsonParser) uTF8StreamJsonParser0, (JavaType) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 154)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\uFFFD\uFFFD\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test045() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ArrayList<IntNode> arrayList0 = new ArrayList<IntNode>();
assertNotNull(arrayList0);
assertTrue(arrayList0.isEmpty());
assertEquals(0, arrayList0.size());
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isFloat());
assertTrue(missingNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertNull(missingNode0.textValue());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isShort());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.booleanValue());
assertEquals(0, missingNode0.size());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) arrayList0, (Object) missingNode0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(arrayList0.isEmpty());
assertEquals(0, arrayList0.size());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isFloat());
assertTrue(missingNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertNull(missingNode0.textValue());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isShort());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.booleanValue());
assertEquals(0, missingNode0.size());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(missingNode0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isFloat());
assertTrue(missingNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertNull(missingNode0.textValue());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isShort());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.isObject());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertFalse(missingNode0.booleanValue());
assertEquals(0, missingNode0.size());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test046() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isMissingNode());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
double double0 = booleanNode0.asDouble();
assertEquals(1.0, double0, 0.01);
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isMissingNode());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isMissingNode());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DefaultDeserializationContext defaultDeserializationContext0 = objectReader0.createDeserializationContext((JsonParser) null);
assertNotNull(defaultDeserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._findTreeDeserializer(defaultDeserializationContext0);
assertNotNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
assertTrue(jsonDeserializer0.isCachable());
assertEquals(AccessPattern.CONSTANT, jsonDeserializer0.getNullAccessPattern());
assertEquals(AccessPattern.DYNAMIC, jsonDeserializer0.getEmptyAccessPattern());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isMissingNode());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isInt());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isBigInteger());
assertTrue(arrayNode0.isArray());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isBigDecimal());
assertEquals("", arrayNode0.asText());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
ObjectNode objectNode0 = objectMapper0.createObjectNode();
assertNotNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isArray());
assertTrue(objectNode0.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
Short short0 = new Short((short)0);
assertEquals((short)0, (short)short0);
assertNotNull(short0);
// Undeclared exception!
try {
objectReader0.readValue((JsonNode) objectNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test047() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)99;
byteArray0[1] = (byte) (-105);
byteArray0[2] = (byte)47;
byteArray0[3] = (byte) (-19);
byteArray0[4] = (byte) (-105);
byteArray0[5] = (byte)56;
byteArray0[6] = (byte)50;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, (-1933821264), 2199);
assertArrayEquals(new byte[] {(byte)99, (byte) (-105), (byte)47, (byte) (-19), (byte) (-105), (byte)56, (byte)50}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(2199, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)99, (byte) (-105), (byte)47, (byte) (-19), (byte) (-105), (byte)56, (byte)50}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(2199, byteArrayInputStream0.available());
// Undeclared exception!
try {
objectReader0.readTree((DataInput) dataInputStream0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test048() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
String string0 = "{%\"z k<uGMqT";
JsonFactory jsonFactory0 = new JsonFactory(objectReader1);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectReader0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonGenerator_Feature0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonFactory jsonFactory3 = jsonFactory2.copy();
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory3.createParser((Reader) pipedReader0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
try {
objectReader1._bindAndClose(readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test049() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
NullNode nullNode0 = jsonNodeFactory0.nullNode();
assertNotNull(nullNode0);
assertFalse(nullNode0.isBigInteger());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertEquals("null", nullNode0.asText());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isObject());
assertNull(nullNode0.numberType());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isInt());
Class<ObjectNode> class0 = ObjectNode.class;
ObjectNode objectNode0 = objectReader0.treeToValue((TreeNode) nullNode0, class0);
assertNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(nullNode0.isBigInteger());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertEquals("null", nullNode0.asText());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isIntegralNumber());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isObject());
assertNull(nullNode0.numberType());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isInt());
// Undeclared exception!
try {
objectReader0.readValue((JsonNode) nullNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test050() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
JsonpCharacterEscapes jsonpCharacterEscapes0 = JsonpCharacterEscapes.instance();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonParser_Feature0);
assertNotNull(jsonFactory2);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(12289, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonFactory jsonFactory3 = jsonFactory2.setRootValueSeparator("JSON");
assertNotNull(jsonFactory3);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals(12289, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(12289, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
JsonParser.Feature jsonParser_Feature1 = JsonParser.Feature.ALLOW_MISSING_VALUES;
JsonFactory jsonFactory4 = jsonFactory3.configure(jsonParser_Feature1, true);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature1));
assertFalse(jsonParser_Feature1.equals((Object)jsonParser_Feature0));
assertNotNull(jsonFactory4);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(12801, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(12801, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12801, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(12801, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(12801, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals("JSON", jsonFactory4.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonParser_Feature1, jsonParser_Feature0);
assertSame(jsonFactory4, jsonFactory0);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory3);
assertSame(jsonFactory4, jsonFactory2);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.STRICT_DUPLICATE_DETECTION;
JsonFactory jsonFactory5 = jsonFactory4.configure(jsonGenerator_Feature0, true);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature1));
assertFalse(jsonParser_Feature1.equals((Object)jsonParser_Feature0));
assertNotNull(jsonFactory5);
assertEquals(287, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(12801, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(12801, jsonFactory1.getParserFeatures());
assertEquals(287, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12801, jsonFactory2.getParserFeatures());
assertEquals(287, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(12801, jsonFactory3.getParserFeatures());
assertEquals(287, jsonFactory3.getGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(12801, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(287, jsonFactory4.getGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals("JSON", jsonFactory4.getRootValueSeparator());
assertEquals(0, jsonFactory5.getFormatParserFeatures());
assertTrue(jsonFactory5.canParseAsync());
assertFalse(jsonFactory5.requiresCustomCodec());
assertEquals(12801, jsonFactory5.getParserFeatures());
assertTrue(jsonFactory5.canUseCharArrays());
assertEquals("JSON", jsonFactory5.getFormatName());
assertEquals("JSON", jsonFactory5.getRootValueSeparator());
assertEquals(287, jsonFactory5.getGeneratorFeatures());
assertFalse(jsonFactory5.canHandleBinaryNatively());
assertEquals(0, jsonFactory5.getFormatGeneratorFeatures());
assertFalse(jsonFactory5.requiresPropertyOrdering());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory5);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory5);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory5);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory5);
assertNotSame(jsonParser_Feature1, jsonParser_Feature0);
assertSame(jsonFactory4, jsonFactory0);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory3);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory5);
assertSame(jsonFactory5, jsonFactory3);
assertSame(jsonFactory5, jsonFactory0);
assertSame(jsonFactory5, jsonFactory2);
assertSame(jsonFactory5, jsonFactory4);
assertSame(jsonFactory5, jsonFactory1);
JsonFactory jsonFactory6 = jsonFactory5.setCharacterEscapes(jsonpCharacterEscapes0);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature1));
assertFalse(jsonParser_Feature1.equals((Object)jsonParser_Feature0));
assertNotNull(jsonFactory6);
assertEquals(287, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(12801, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(12801, jsonFactory1.getParserFeatures());
assertEquals(287, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12801, jsonFactory2.getParserFeatures());
assertEquals(287, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(12801, jsonFactory3.getParserFeatures());
assertEquals(287, jsonFactory3.getGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(12801, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(287, jsonFactory4.getGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals("JSON", jsonFactory4.getRootValueSeparator());
assertEquals(0, jsonFactory5.getFormatParserFeatures());
assertTrue(jsonFactory5.canParseAsync());
assertFalse(jsonFactory5.requiresCustomCodec());
assertEquals(12801, jsonFactory5.getParserFeatures());
assertTrue(jsonFactory5.canUseCharArrays());
assertEquals("JSON", jsonFactory5.getFormatName());
assertEquals("JSON", jsonFactory5.getRootValueSeparator());
assertEquals(287, jsonFactory5.getGeneratorFeatures());
assertFalse(jsonFactory5.canHandleBinaryNatively());
assertEquals(0, jsonFactory5.getFormatGeneratorFeatures());
assertFalse(jsonFactory5.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory6.getFormatName());
assertFalse(jsonFactory6.requiresCustomCodec());
assertEquals(0, jsonFactory6.getFormatParserFeatures());
assertFalse(jsonFactory6.canHandleBinaryNatively());
assertEquals(0, jsonFactory6.getFormatGeneratorFeatures());
assertFalse(jsonFactory6.requiresPropertyOrdering());
assertTrue(jsonFactory6.canParseAsync());
assertEquals("JSON", jsonFactory6.getRootValueSeparator());
assertTrue(jsonFactory6.canUseCharArrays());
assertEquals(12801, jsonFactory6.getParserFeatures());
assertEquals(287, jsonFactory6.getGeneratorFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory6);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory5);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory5);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory6);
assertNotSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory5);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory6);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory5);
assertSame(jsonFactory3, jsonFactory6);
assertNotSame(jsonParser_Feature1, jsonParser_Feature0);
assertSame(jsonFactory4, jsonFactory0);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory6);
assertSame(jsonFactory4, jsonFactory3);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory5);
assertSame(jsonFactory5, jsonFactory3);
assertSame(jsonFactory5, jsonFactory0);
assertSame(jsonFactory5, jsonFactory2);
assertSame(jsonFactory5, jsonFactory4);
assertSame(jsonFactory5, jsonFactory1);
assertSame(jsonFactory5, jsonFactory6);
assertSame(jsonFactory6, jsonFactory3);
assertSame(jsonFactory6, jsonFactory2);
assertSame(jsonFactory6, jsonFactory5);
assertSame(jsonFactory6, jsonFactory1);
assertSame(jsonFactory6, jsonFactory0);
assertSame(jsonFactory6, jsonFactory4);
IntNode intNode0 = IntNode.valueOf(4469);
assertNotNull(intNode0);
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.isInt());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigDecimal());
assertEquals((short)4469, intNode0.shortValue());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals(4469L, intNode0.longValue());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isMissingNode());
assertTrue(intNode0.isEmpty());
assertEquals(4469, intNode0.intValue());
assertTrue(intNode0.canConvertToInt());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isShort());
assertTrue(intNode0.canConvertToLong());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isObject());
assertEquals(4469.0, intNode0.doubleValue(), 0.01);
assertEquals(0, intNode0.size());
assertNull(intNode0.textValue());
assertEquals(4469.0F, intNode0.floatValue(), 0.01F);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isBigDecimal());
assertTrue(objectNode1.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.booleanValue());
assertEquals("", objectNode1.asText());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isFloat());
assertEquals(0, objectNode1.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectNode0.put("JSON", "JSON");
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertNotNull(objectNode2);
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals(1, objectNode2.size());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(concurrentHashMap0.isEmpty());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
ObjectNode objectNode3 = objectNode0.put("JSON", bigDecimal0);
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode3.equals((Object)objectNode1));
assertNotNull(objectNode3);
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals("", objectNode3.asText());
assertEquals(1, objectNode3.size());
assertNull(objectNode3.textValue());
assertFalse(objectNode3.isFloatingPointNumber());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.booleanValue());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isArray());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isDouble());
assertFalse(objectNode3.isBigInteger());
assertFalse(objectNode3.isMissingNode());
assertFalse(concurrentHashMap0.isEmpty());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode3);
assertSame(objectNode0, objectNode2);
assertNotSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode2);
JsonNode jsonNode0 = objectNode3.set("SDT=^L$vxvH=T|", objectNode2);
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode2.equals((Object)objectNode1));
assertFalse(objectNode3.equals((Object)objectNode1));
assertFalse(jsonNode0.equals((Object)objectNode1));
assertNotNull(jsonNode0);
assertEquals(2, objectNode0.size());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.booleanValue());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals(2, objectNode2.size());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals("", objectNode3.asText());
assertNull(objectNode3.textValue());
assertFalse(objectNode3.isFloatingPointNumber());
assertEquals(2, objectNode3.size());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.booleanValue());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isArray());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isDouble());
assertFalse(objectNode3.isBigInteger());
assertFalse(objectNode3.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigInteger());
assertEquals(2, jsonNode0.size());
assertFalse(jsonNode0.isShort());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isBigDecimal());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.isFloat());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(concurrentHashMap0.isEmpty());
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, jsonNode0);
assertSame(objectNode0, objectNode3);
assertSame(objectNode0, objectNode2);
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
assertSame(objectNode2, objectNode3);
assertSame(objectNode2, jsonNode0);
assertSame(objectNode3, jsonNode0);
assertNotSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode2);
assertSame(jsonNode0, objectNode2);
assertSame(jsonNode0, objectNode3);
assertSame(jsonNode0, objectNode0);
assertNotSame(jsonNode0, objectNode1);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) jsonNode0, class0);
fail("Expecting exception: StackOverflowError");
} catch(StackOverflowError e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test051() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
int int0 = 55;
ObjectReader objectReader2 = objectReader1.withValueToUpdate(objectReader0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
Class<Object> class0 = Object.class;
int int1 = 1338;
CoreXMLDeserializers.Std coreXMLDeserializers_Std0 = new CoreXMLDeserializers.Std(class0, 1338);
assertNotNull(coreXMLDeserializers_Std0);
assertFalse(coreXMLDeserializers_Std0.isCachable());
assertEquals(AccessPattern.CONSTANT, coreXMLDeserializers_Std0.getEmptyAccessPattern());
assertEquals(AccessPattern.ALWAYS_NULL, coreXMLDeserializers_Std0.getNullAccessPattern());
JavaType javaType0 = coreXMLDeserializers_Std0.getValueType();
assertNull(javaType0);
assertFalse(coreXMLDeserializers_Std0.isCachable());
assertEquals(AccessPattern.CONSTANT, coreXMLDeserializers_Std0.getEmptyAccessPattern());
assertEquals(AccessPattern.ALWAYS_NULL, coreXMLDeserializers_Std0.getNullAccessPattern());
// Undeclared exception!
try {
objectReader1.withType((JavaType) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test052() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals((-1), uRL0.getPort());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
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);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
IntNode intNode0 = IntNode.valueOf((-372));
assertNotNull(intNode0);
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertEquals((-372.0F), intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isShort());
assertEquals((-372), intNode0.intValue());
assertFalse(intNode0.isFloatingPointNumber());
assertTrue(intNode0.isEmpty());
assertFalse(intNode0.isNaN());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isMissingNode());
assertTrue(intNode0.isInt());
assertFalse(intNode0.booleanValue());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertEquals((-372.0), intNode0.doubleValue(), 0.01);
assertEquals((short) (-372), intNode0.shortValue());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.canConvertToInt());
assertFalse(intNode0.isArray());
assertEquals((-372L), intNode0.longValue());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isLong());
assertNull(intNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isBigDecimal());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals(0, objectNode1.size());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isFloatingPointNumber());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.isLong());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectNode1.putNull("");
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode1.equals((Object)objectNode0));
assertFalse(objectNode2.equals((Object)objectNode0));
assertNotNull(objectNode2);
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertEquals(1, objectNode1.size());
assertNull(objectNode1.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isLong());
assertFalse(objectNode2.isInt());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertTrue(objectNode2.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isBigDecimal());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isFloat());
assertEquals(1, objectNode2.size());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
assertSame(objectNode2, objectNode1);
assertNotSame(objectNode2, objectNode0);
ObjectNode objectNode3 = objectNode2.put("JSON", "JSON");
assertFalse(objectNode3.equals((Object)objectNode0));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode1.equals((Object)objectNode0));
assertFalse(objectNode2.equals((Object)objectNode0));
assertNotNull(objectNode3);
assertFalse(objectNode3.isBigDecimal());
assertEquals(2, objectNode3.size());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isEmpty());
assertEquals("", objectNode3.asText());
assertFalse(objectNode3.isArray());
assertFalse(objectNode3.isBigInteger());
assertNull(objectNode3.textValue());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.isMissingNode());
assertFalse(objectNode3.isInt());
assertFalse(objectNode3.isDouble());
assertFalse(objectNode3.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isFloatingPointNumber());
assertNull(objectNode3.numberType());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isFloat());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.booleanValue());
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertEquals(2, objectNode1.size());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isLong());
assertFalse(objectNode2.isInt());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertTrue(objectNode2.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isBigDecimal());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isBigInteger());
assertEquals(2, objectNode2.size());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isFloat());
assertSame(objectNode3, objectNode2);
assertSame(objectNode3, objectNode1);
assertNotSame(objectNode3, objectNode0);
assertNotSame(objectNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode3);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
assertSame(objectNode2, objectNode3);
assertSame(objectNode2, objectNode1);
assertNotSame(objectNode2, objectNode0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
ObjectNode objectNode4 = objectNode1.put("0LS^>iDaXmbY>", bigDecimal0);
assertFalse(objectNode4.equals((Object)objectNode0));
assertFalse(objectNode0.equals((Object)objectNode3));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode4);
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertFalse(objectNode4.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode4.asToken());
assertFalse(objectNode4.isShort());
assertFalse(objectNode4.isInt());
assertFalse(objectNode4.isBigInteger());
assertFalse(objectNode4.booleanValue());
assertNull(objectNode4.textValue());
assertEquals(3, objectNode4.size());
assertNull(objectNode4.numberType());
assertFalse(objectNode4.isEmpty());
assertTrue(objectNode4.isObject());
assertFalse(objectNode4.isFloatingPointNumber());
assertFalse(objectNode4.isLong());
assertFalse(objectNode4.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode4.getNodeType());
assertFalse(objectNode4.isFloat());
assertFalse(objectNode4.isIntegralNumber());
assertFalse(objectNode4.isDouble());
assertFalse(objectNode4.isArray());
assertEquals("", objectNode4.asText());
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertEquals(3, objectNode1.size());
assertNull(objectNode1.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isLong());
assertNotSame(objectNode4, objectNode0);
assertSame(objectNode4, objectNode2);
assertSame(objectNode4, objectNode1);
assertSame(objectNode4, objectNode3);
assertNotSame(objectNode0, objectNode4);
assertNotSame(objectNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode4);
assertSame(objectNode1, objectNode3);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
JsonNode jsonNode0 = objectNode1.set("JSON", objectNode4);
assertFalse(objectNode4.equals((Object)objectNode0));
assertFalse(jsonNode0.equals((Object)objectNode0));
assertFalse(objectNode0.equals((Object)objectNode4));
assertFalse(objectNode0.equals((Object)objectNode3));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode1.equals((Object)objectNode0));
assertNotNull(jsonNode0);
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertFalse(objectNode4.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode4.asToken());
assertFalse(objectNode4.isShort());
assertFalse(objectNode4.isInt());
assertFalse(objectNode4.isBigInteger());
assertFalse(objectNode4.booleanValue());
assertNull(objectNode4.textValue());
assertEquals(3, objectNode4.size());
assertNull(objectNode4.numberType());
assertFalse(objectNode4.isEmpty());
assertTrue(objectNode4.isObject());
assertFalse(objectNode4.isFloatingPointNumber());
assertFalse(objectNode4.isLong());
assertFalse(objectNode4.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode4.getNodeType());
assertFalse(objectNode4.isFloat());
assertFalse(objectNode4.isIntegralNumber());
assertFalse(objectNode4.isDouble());
assertFalse(objectNode4.isArray());
assertEquals("", objectNode4.asText());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.isInt());
assertEquals(3, jsonNode0.size());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isShort());
assertNull(jsonNode0.numberType());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertTrue(concurrentHashMap0.isEmpty());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertEquals(3, objectNode1.size());
assertNull(objectNode1.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isLong());
assertSame(objectNode4, jsonNode0);
assertNotSame(objectNode4, objectNode0);
assertSame(objectNode4, objectNode2);
assertSame(objectNode4, objectNode1);
assertSame(objectNode4, objectNode3);
assertNotSame(jsonNode0, objectNode0);
assertSame(jsonNode0, objectNode2);
assertSame(jsonNode0, objectNode4);
assertSame(jsonNode0, objectNode1);
assertSame(jsonNode0, objectNode3);
assertNotSame(objectNode0, objectNode4);
assertNotSame(objectNode0, jsonNode0);
assertNotSame(objectNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode4);
assertSame(objectNode1, objectNode3);
assertSame(objectNode1, jsonNode0);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) jsonNode0, class0);
fail("Expecting exception: StackOverflowError");
} catch(StackOverflowError e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test053() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes((CharacterEscapes) null);
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
char[] charArray0 = new char[5];
charArray0[0] = 't';
charArray0[1] = '+';
charArray0[2] = '}';
charArray0[3] = '~';
charArray0[4] = 'T';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory1.createParser(charArray0, 97, 97);
assertArrayEquals(new char[] {'t', '+', '}', '~', 'T'}, charArray0);
assertEquals(5, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = (DefaultDeserializationContext.Impl)objectReader0._context;
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
PlaceholderForType placeholderForType0 = new PlaceholderForType(249);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
// Undeclared exception!
try {
objectReader0._verifyNoTrailingTokens(readerBasedJsonParser0, defaultDeserializationContext_Impl0, placeholderForType0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 97
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test054() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
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);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader1 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
IntNode intNode0 = IntNode.valueOf((-372));
assertNotNull(intNode0);
assertEquals(0, intNode0.size());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isMissingNode());
assertNull(intNode0.textValue());
assertEquals((-372.0), intNode0.doubleValue(), 0.01);
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.isEmpty());
assertEquals((-372L), intNode0.longValue());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertEquals((-372.0F), intNode0.floatValue(), 0.01F);
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isShort());
assertFalse(intNode0.isObject());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isFloat());
assertEquals((short) (-372), intNode0.shortValue());
assertTrue(intNode0.canConvertToInt());
assertEquals((-372), intNode0.intValue());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.booleanValue());
Class<ObjectNode> class0 = ObjectNode.class;
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isShort());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isShort());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isBigDecimal());
assertTrue(objectNode1.isEmpty());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertEquals(0, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isShort());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectNode0.put("JSON", "JSON");
assertFalse(objectNode2.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode1));
assertNotNull(objectNode2);
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertEquals(1, objectNode2.size());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertSame(objectNode2, objectNode0);
assertNotSame(objectNode2, objectNode1);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
ObjectNode objectNode3 = objectNode2.put("JSON", bigDecimal0);
assertFalse(objectNode2.equals((Object)objectNode1));
assertFalse(objectNode3.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode1));
assertNotNull(objectNode3);
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertEquals(1, objectNode2.size());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertFalse(objectNode3.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isMissingNode());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.booleanValue());
assertFalse(objectNode3.isEmpty());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.isBigDecimal());
assertEquals(1, objectNode3.size());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isBigInteger());
assertNull(objectNode3.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isFloatingPointNumber());
assertFalse(objectNode3.isArray());
assertEquals("", objectNode3.asText());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode3);
assertNotSame(objectNode2, objectNode1);
assertSame(objectNode3, objectNode2);
assertNotSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode0, objectNode3);
JsonNode jsonNode0 = objectNode0.set(" ~+z&~/.g|sgjzxqV4;", objectNode3);
assertFalse(objectNode2.equals((Object)objectNode1));
assertFalse(objectNode3.equals((Object)objectNode1));
assertFalse(jsonNode0.equals((Object)objectNode1));
assertFalse(objectNode0.equals((Object)objectNode1));
assertNotNull(jsonNode0);
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isFloat());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isMissingNode());
assertEquals(2, objectNode2.size());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertFalse(objectNode3.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isMissingNode());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.booleanValue());
assertFalse(objectNode3.isEmpty());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.isBigDecimal());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isBigInteger());
assertEquals(2, objectNode3.size());
assertNull(objectNode3.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isFloatingPointNumber());
assertFalse(objectNode3.isArray());
assertEquals("", objectNode3.asText());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isObject());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertEquals(2, jsonNode0.size());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertEquals(2, objectNode0.size());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertSame(objectNode2, jsonNode0);
assertSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode3);
assertNotSame(objectNode2, objectNode1);
assertSame(objectNode3, objectNode2);
assertSame(objectNode3, jsonNode0);
assertNotSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertNotSame(jsonNode0, objectNode1);
assertSame(jsonNode0, objectNode2);
assertSame(jsonNode0, objectNode0);
assertSame(jsonNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode0, objectNode3);
assertSame(objectNode0, jsonNode0);
// Undeclared exception!
try {
objectReader1.treeToValue((TreeNode) objectNode1, class0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test055() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
IntNode intNode0 = IntNode.valueOf((-2));
assertNotNull(intNode0);
assertNull(intNode0.textValue());
assertTrue(intNode0.canConvertToLong());
assertEquals((-2.0), intNode0.doubleValue(), 0.01);
assertEquals((-2L), intNode0.longValue());
assertFalse(intNode0.isNaN());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertFalse(intNode0.isMissingNode());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isArray());
assertEquals(0, intNode0.size());
assertEquals((-2), intNode0.intValue());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isBigInteger());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isBigDecimal());
assertEquals((short) (-2), intNode0.shortValue());
assertFalse(intNode0.isShort());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.canConvertToInt());
assertFalse(intNode0.isObject());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isLong());
assertTrue(intNode0.isEmpty());
assertEquals((-2.0F), intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isDouble());
ObjectReader objectReader3 = objectMapper0.reader();
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
objectReader3._verifySchemaType((FormatSchema) null);
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
Class<List> class0 = List.class;
CollectionType collectionType0 = typeFactory0.constructRawCollectionType(class0);
assertNotNull(collectionType0);
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isConcrete());
ReferenceType referenceType0 = ReferenceType.upgradeFrom(collectionType0, collectionType0);
assertNotNull(referenceType0);
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isConcrete());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(1, referenceType0.containedTypeCount());
assertTrue(referenceType0.isReferenceType());
assertTrue(referenceType0.isAbstract());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isConcrete());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isPrimitive());
assertTrue(referenceType0.isInterface());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isEnumType());
ReferenceType referenceType1 = (ReferenceType)referenceType0.withTypeHandler(objectReader1);
assertTrue(referenceType1.equals((Object)referenceType0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader3));
assertNotNull(referenceType1);
assertEquals(1, referenceType1.containedTypeCount());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.hasHandlers());
assertTrue(referenceType1.isInterface());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isConcrete());
assertFalse(referenceType1.isFinal());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.isAbstract());
assertFalse(referenceType1.isArrayType());
assertTrue(referenceType1.isReferenceType());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isConcrete());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(1, referenceType0.containedTypeCount());
assertTrue(referenceType0.isReferenceType());
assertTrue(referenceType0.isAbstract());
assertFalse(referenceType0.isFinal());
assertFalse(referenceType0.isArrayType());
assertFalse(referenceType0.isConcrete());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isPrimitive());
assertTrue(referenceType0.isInterface());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isEnumType());
assertNotSame(referenceType1, referenceType0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader3);
assertNotSame(referenceType0, referenceType1);
// Undeclared exception!
try {
objectReader3.forType((JavaType) referenceType1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test056() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
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, uRL0, true);
assertNotNull(iOContext0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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("com.fasterxml.jackson.core.type.WritableTypeId$Inclusion");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectMapper0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
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());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
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);
FormatSchema formatSchema0 = readerBasedJsonParser0.getSchema();
assertNull(formatSchema0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
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());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
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);
ObjectReader objectReader1 = objectMapper0.reader((FormatSchema) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withValueToUpdate(charsToNameCanonicalizer0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
ObjectReader objectReader3 = objectReader0.withRootName("0LS^>iDaXmbY>");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
IntNode intNode0 = IntNode.valueOf(2);
assertNotNull(intNode0);
assertEquals(2.0F, intNode0.floatValue(), 0.01F);
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertNull(intNode0.textValue());
assertEquals(2.0, intNode0.doubleValue(), 0.01);
assertEquals(2, intNode0.intValue());
assertFalse(intNode0.isObject());
assertTrue(intNode0.canConvertToLong());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isShort());
assertEquals(0, intNode0.size());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isFloat());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isBigDecimal());
assertEquals(2L, intNode0.longValue());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isMissingNode());
assertFalse(intNode0.isLong());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.canConvertToInt());
assertFalse(intNode0.isNaN());
assertEquals((short)2, intNode0.shortValue());
assertFalse(intNode0.isFloatingPointNumber());
assertTrue(intNode0.isEmpty());
Class<ObjectNode> class0 = ObjectNode.class;
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
ObjectNode objectNode1 = objectNode0.deepCopy();
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isDouble());
assertEquals(0, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isArray());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigInteger());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectNode1.put("JSON", "");
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode1.equals((Object)objectNode0));
assertFalse(objectNode2.equals((Object)objectNode0));
assertNotNull(objectNode2);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isDouble());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isArray());
assertEquals(1, objectNode1.size());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isShort());
assertEquals(1, objectNode2.size());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isArray());
assertEquals("", objectNode2.asText());
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode2);
assertNotSame(objectNode1, objectNode0);
assertNotSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode1);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertNotNull(bigDecimal0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
ObjectNode objectNode3 = objectNode2.put("nQr", bigDecimal0);
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode1.equals((Object)objectNode0));
assertFalse(objectNode2.equals((Object)objectNode0));
assertFalse(objectNode3.equals((Object)objectNode0));
assertNotNull(objectNode3);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isDouble());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isArray());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigInteger());
assertEquals(2, objectNode1.size());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode2.isBigInteger());
assertEquals(2, objectNode2.size());
assertNull(objectNode2.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isArray());
assertEquals("", objectNode2.asText());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertFalse(objectNode3.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.booleanValue());
assertNull(objectNode3.textValue());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isBigInteger());
assertEquals(2, objectNode3.size());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isFloatingPointNumber());
assertFalse(objectNode3.isMissingNode());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isDouble());
assertEquals("", objectNode3.asText());
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode2);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode3);
assertSame(objectNode2, objectNode3);
assertNotSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode1);
assertNotSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode2);
JsonNode jsonNode0 = objectNode3.set("No value type configured for ObjectReader", objectNode2);
assertFalse(objectNode0.equals((Object)objectNode2));
assertFalse(objectNode0.equals((Object)objectNode3));
assertFalse(objectNode0.equals((Object)objectNode1));
assertFalse(objectNode1.equals((Object)objectNode0));
assertFalse(objectNode2.equals((Object)objectNode0));
assertFalse(objectNode3.equals((Object)objectNode0));
assertFalse(jsonNode0.equals((Object)objectNode0));
assertNotNull(jsonNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isDouble());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isArray());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isBigInteger());
assertEquals(3, objectNode1.size());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isFloat());
assertNull(objectNode1.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode2.isBigInteger());
assertEquals(3, objectNode2.size());
assertNull(objectNode2.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.booleanValue());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isArray());
assertEquals("", objectNode2.asText());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertFalse(objectNode3.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.booleanValue());
assertNull(objectNode3.textValue());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isBigInteger());
assertNull(objectNode3.numberType());
assertEquals(3, objectNode3.size());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isInt());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isFloatingPointNumber());
assertFalse(objectNode3.isMissingNode());
assertFalse(objectNode3.isLong());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isDouble());
assertEquals("", objectNode3.asText());
assertFalse(jsonNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.numberType());
assertEquals(3, jsonNode0.size());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode0, jsonNode0);
assertNotSame(objectNode0, objectNode3);
assertNotSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode2);
assertSame(objectNode1, jsonNode0);
assertNotSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode3);
assertSame(objectNode2, jsonNode0);
assertSame(objectNode2, objectNode3);
assertNotSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode1);
assertSame(objectNode3, jsonNode0);
assertNotSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode2);
assertSame(jsonNode0, objectNode3);
assertNotSame(jsonNode0, objectNode0);
assertSame(jsonNode0, objectNode1);
assertSame(jsonNode0, objectNode2);
// Undeclared exception!
try {
objectReader3.treeToValue((TreeNode) jsonNode0, class0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test057() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
IntNode intNode0 = IntNode.valueOf((-2));
assertNotNull(intNode0);
assertFalse(intNode0.isBigInteger());
assertTrue(intNode0.isInt());
assertTrue(intNode0.canConvertToInt());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isShort());
assertNull(intNode0.textValue());
assertEquals((-2.0), intNode0.doubleValue(), 0.01);
assertTrue(intNode0.canConvertToLong());
assertTrue(intNode0.isEmpty());
assertEquals((-2.0F), intNode0.floatValue(), 0.01F);
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals((-2L), intNode0.longValue());
assertEquals(0, intNode0.size());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isDouble());
assertEquals((-2), intNode0.intValue());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isNaN());
assertFalse(intNode0.isMissingNode());
assertEquals((short) (-2), intNode0.shortValue());
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader2.treeToValue((TreeNode) intNode0, class0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test058() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
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);
assertNotNull(iOContext0);
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(0, 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 iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
PipedReader pipedReader0 = new PipedReader(2);
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[8];
charArray0[0] = 'a';
charArray0[1] = 'P';
charArray0[2] = '&';
charArray0[3] = '7';
charArray0[4] = 'I';
charArray0[5] = ')';
charArray0[6] = 'o';
charArray0[7] = '';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1023), pipedReader0, objectReader0, charsToNameCanonicalizer0, charArray0, 1353, (-5571), true);
assertArrayEquals(new char[] {'a', 'P', '&', '7', 'I', ')', 'o', ''}, charArray0);
assertEquals(8, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1023), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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 readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideFormatFeatures((-57), 0);
assertArrayEquals(new char[] {'a', 'P', '&', '7', 'I', ')', 'o', ''}, charArray0);
assertEquals(8, charArray0.length);
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1023), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals((-1023), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
Class<String> class0 = String.class;
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1, class0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test059() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationContext deserializationContext0 = objectMapper0.getDeserializationContext();
assertNotNull(deserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, deserializationContext0.getDeserializationFeatures());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_TARGET;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setRootValueSeparator("");
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory3 = jsonFactory2.disable(jsonParser_Feature0);
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals("", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
char[] charArray0 = new char[2];
charArray0[0] = 'E';
charArray0[1] = 'e';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory3.createParser(charArray0, (-1269), (-1269));
assertArrayEquals(new char[] {'E', 'e'}, charArray0);
assertEquals(2, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals("", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
// Undeclared exception!
try {
objectReader0._initForReading(deserializationContext0, readerBasedJsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test060() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[9];
objectReaderArray0[0] = objectReader0;
BaseSettings baseSettings0 = ObjectMapper.DEFAULT_BASE;
assertNotNull(baseSettings0);
assertFalse(baseSettings0.hasExplicitTimeZone());
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
SimpleMixInResolver simpleMixInResolver0 = new SimpleMixInResolver((ClassIntrospector.MixInResolver) null);
assertNotNull(simpleMixInResolver0);
assertEquals(0, simpleMixInResolver0.localSize());
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = new ConfigOverrides();
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig(baseSettings0, stdSubtypeResolver0, simpleMixInResolver0, rootNameLookup0, configOverrides0);
assertNotNull(deserializationConfig0);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertNotNull(objectMapper2);
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
SimpleMixInResolver simpleMixInResolver1 = objectMapper2._mixIns;
assertFalse(simpleMixInResolver1.equals((Object)simpleMixInResolver0));
assertNotNull(simpleMixInResolver1);
assertEquals(0, simpleMixInResolver1.localSize());
assertNotSame(simpleMixInResolver1, simpleMixInResolver0);
DeserializationConfig deserializationConfig1 = new DeserializationConfig(deserializationConfig0, simpleMixInResolver1);
assertFalse(simpleMixInResolver0.equals((Object)simpleMixInResolver1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(simpleMixInResolver1.equals((Object)simpleMixInResolver0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertNotNull(deserializationConfig1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver1.localSize());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig1.mixInCount());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertNull(deserializationConfig1.getRootName());
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ConcurrentHashMap<SimpleObjectIdResolver, FilteringParserDelegate> concurrentHashMap0 = new ConcurrentHashMap<SimpleObjectIdResolver, FilteringParserDelegate>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ContextAttributes contextAttributes1 = contextAttributes0.withSharedAttributes(concurrentHashMap0);
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertNotNull(contextAttributes1);
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(contextAttributes1, contextAttributes0);
assertNotSame(contextAttributes0, contextAttributes1);
DeserializationConfig deserializationConfig2 = new DeserializationConfig(deserializationConfig1, contextAttributes1);
assertFalse(simpleMixInResolver0.equals((Object)simpleMixInResolver1));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(simpleMixInResolver1.equals((Object)simpleMixInResolver0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig0));
assertNotNull(deserializationConfig2);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver1.localSize());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig1.mixInCount());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertNull(deserializationConfig1.getRootName());
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(deserializationConfig2.useRootWrapping());
assertTrue(deserializationConfig2.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig2.canOverrideAccessModifiers());
assertEquals(237020304, deserializationConfig2.getDeserializationFeatures());
assertEquals(0, deserializationConfig2.mixInCount());
assertNull(deserializationConfig2.getDefaultMergeable());
assertFalse(deserializationConfig2.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig2.getRootName());
assertFalse(deserializationConfig2.requiresFullValue());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
ObjectReader objectReader1 = new ObjectReader(objectMapper0, deserializationConfig2);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(simpleMixInResolver0.equals((Object)simpleMixInResolver1));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig2));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(simpleMixInResolver1.equals((Object)simpleMixInResolver0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig2));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver1.localSize());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig1.mixInCount());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertNull(deserializationConfig1.getRootName());
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(deserializationConfig2.useRootWrapping());
assertTrue(deserializationConfig2.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig2.canOverrideAccessModifiers());
assertEquals(237020304, deserializationConfig2.getDeserializationFeatures());
assertEquals(0, deserializationConfig2.mixInCount());
assertNull(deserializationConfig2.getDefaultMergeable());
assertFalse(deserializationConfig2.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig2.getRootName());
assertFalse(deserializationConfig2.requiresFullValue());
objectReaderArray0[1] = objectReader1;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
ObjectReader objectReader2 = objectMapper1._newReader(deserializationConfig1);
assertFalse(simpleMixInResolver0.equals((Object)simpleMixInResolver1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig2));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(simpleMixInResolver1.equals((Object)simpleMixInResolver0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig2));
assertNotNull(objectReader2);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver1.localSize());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig1.mixInCount());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertNull(deserializationConfig1.getRootName());
assertNotSame(simpleMixInResolver0, simpleMixInResolver1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(deserializationConfig0, deserializationConfig1);
assertNotSame(deserializationConfig0, deserializationConfig2);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(simpleMixInResolver1, simpleMixInResolver0);
assertNotSame(deserializationConfig1, deserializationConfig0);
assertNotSame(deserializationConfig1, deserializationConfig2);
objectReaderArray0[5] = objectReader2;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[7] = objectReader0;
objectReaderArray0[8] = objectReader0;
ObjectReader objectReader3 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(9, objectReaderArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
URL uRL0 = MockURL.getHttpExample();
assertNotNull(uRL0);
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getRef());
assertEquals("http", uRL0.getProtocol());
assertEquals((-1), uRL0.getPort());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getAuthority());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader4 = objectMapper1.reader(jsonNodeFactory0);
assertFalse(objectReader4.equals((Object)objectReader3));
assertFalse(objectReader4.equals((Object)objectReader0));
assertFalse(objectReader4.equals((Object)objectReader2));
assertFalse(objectReader4.equals((Object)objectReader1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader4);
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectReader4, objectReader3);
assertNotSame(objectReader4, objectReader0);
assertNotSame(objectReader4, objectReader2);
assertNotSame(objectReader4, objectReader1);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
try {
objectReader4.readValues(uRL0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Could not find: www.someFakeButWellFormedURL.org
//
verifyException("org.evosuite.runtime.mock.java.net.EvoHttpURLConnection", e);
}
}
@Test(timeout = 4000)
public void test061() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator("s7|vv)");
assertNotNull(jsonFactory1);
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("s7|vv)", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("s7|vv)", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
NonBlockingJsonParser nonBlockingJsonParser0 = (NonBlockingJsonParser)jsonFactory1.createNonBlockingByteArrayParser();
assertNotNull(nonBlockingJsonParser0);
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("s7|vv)", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals("s7|vv)", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, nonBlockingJsonParser0.getCurrentTokenId());
assertEquals(0, nonBlockingJsonParser0.getTextOffset());
assertNull(nonBlockingJsonParser0.getCurrentToken());
assertFalse(nonBlockingJsonParser0.hasTextCharacters());
assertFalse(nonBlockingJsonParser0.isNaN());
assertEquals(0L, nonBlockingJsonParser0.getTokenCharacterOffset());
assertEquals(1, nonBlockingJsonParser0.getTokenLineNr());
assertEquals(0, nonBlockingJsonParser0.getTextLength());
assertFalse(nonBlockingJsonParser0.isExpectedStartArrayToken());
assertFalse(nonBlockingJsonParser0.hasCurrentToken());
assertNull(nonBlockingJsonParser0.currentToken());
assertFalse(nonBlockingJsonParser0.isClosed());
assertNull(nonBlockingJsonParser0.getCurrentName());
assertFalse(nonBlockingJsonParser0.requiresCustomCodec());
assertEquals(0, nonBlockingJsonParser0.getFormatFeatures());
assertFalse(nonBlockingJsonParser0.canReadObjectId());
assertNull(nonBlockingJsonParser0.getLastClearedToken());
assertTrue(nonBlockingJsonParser0.canParseAsync());
assertEquals(8193, nonBlockingJsonParser0.getFeatureMask());
assertFalse(nonBlockingJsonParser0.canReadTypeId());
assertTrue(nonBlockingJsonParser0.needMoreInput());
assertEquals(1, nonBlockingJsonParser0.getTokenColumnNr());
assertFalse(nonBlockingJsonParser0.isExpectedStartObjectToken());
assertEquals(0, nonBlockingJsonParser0.currentTokenId());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
// Undeclared exception!
try {
objectReader1.readTree((JsonParser) nonBlockingJsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test062() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.withoutFeatures((JsonParser.Feature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test063() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("some", uRL0.getHost());
assertNull(uRL0.getRef());
assertEquals("some", uRL0.getAuthority());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("file", uRL0.getProtocol());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonFactory jsonFactory1 = jsonFactory0.copy();
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory1.createParser("JSON");
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(readerBasedJsonParser0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
ObjectReader objectReader2 = new ObjectReader(objectReader1, jsonFactory0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = (DefaultDeserializationContext.Impl)objectReader2._context;
assertEquals(0, objectReaderArray0.length);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JavaType javaType0 = null;
try {
objectReader0._verifyNoTrailingTokens(readerBasedJsonParser0, defaultDeserializationContext_Impl0, (JavaType) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'JSON': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"JSON\"; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test064() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getAuthority());
String string0 = "YC:F)!cg6FKKs=_\\j";
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)2;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
MatchStrength matchStrength0 = MatchStrength.INCONCLUSIVE;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMinimalMatch(matchStrength0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.with(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
DataFormatReaders dataFormatReaders3 = dataFormatReaders2.withMaxInputLookahead((byte)2);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders3);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders3.findFormat(byteArray0, (int) (byte)2, 64);
assertArrayEquals(new byte[] {(byte)2, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, objectReaderArray0.length);
assertEquals(8, byteArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders_Match0);
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
try {
objectReader1._detectBindAndReadValues(dataFormatReaders_Match0, true);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test065() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0.forType((Class<?>) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test066() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
PlaceholderForType placeholderForType0 = new PlaceholderForType((-108));
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
JavaType javaType0 = placeholderForType0.getContentType();
assertNull(javaType0);
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
StdKeyDeserializers stdKeyDeserializers0 = new StdKeyDeserializers();
assertNotNull(stdKeyDeserializers0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAdditionalKeyDeserializers(stdKeyDeserializers0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JsonParser jsonParser0 = defaultDeserializationContext_Impl0.getParser();
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNull(jsonParser0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader0._verifyNoTrailingTokens((JsonParser) null, defaultDeserializationContext_Impl0, placeholderForType0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test067() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Stack<IntNode> stack0 = new Stack<IntNode>();
assertNotNull(stack0);
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertEquals(0, stack0.size());
assertTrue(stack0.empty());
assertTrue(stack0.isEmpty());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) stack0, (Object) stack0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertEquals(0, stack0.size());
assertTrue(stack0.empty());
assertTrue(stack0.isEmpty());
JsonNode jsonNode0 = objectReader0.readTree("");
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isFloat());
assertTrue(jsonNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isMissingNode());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = JsonpCharacterEscapes.instance();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_YAML_COMMENTS;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonParser_Feature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertNotNull(jsonFactory3);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8197, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8197, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
char[] charArray0 = new char[2];
charArray0[0] = '_';
charArray0[1] = 'a';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory3.createParser(charArray0, 0, 0);
assertArrayEquals(new char[] {'_', 'a'}, charArray0);
assertEquals(2, charArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertNotNull(readerBasedJsonParser0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8197, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8197, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8197, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = (DefaultDeserializationContext.Impl)objectReader0._context;
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
PlaceholderForType placeholderForType0 = new PlaceholderForType(0);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isJavaLangObject());
assertTrue(placeholderForType0.isConcrete());
JavaType javaType0 = placeholderForType0.getContentType();
assertNull(javaType0);
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.useStaticType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isJavaLangObject());
assertTrue(placeholderForType0.isConcrete());
objectReader0._verifyNoTrailingTokens(readerBasedJsonParser0, defaultDeserializationContext_Impl0, (JavaType) null);
assertArrayEquals(new char[] {'_', 'a'}, charArray0);
assertEquals(2, charArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8197, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8197, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8197, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
}
@Test(timeout = 4000)
public void test068() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.withFeatures((FormatFeature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test069() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
Class<ResolvedRecursiveType> class0 = ResolvedRecursiveType.class;
Class<FilteringParserDelegate> class1 = FilteringParserDelegate.class;
Vector<JavaType> vector0 = new Vector<JavaType>();
assertNotNull(vector0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
TypeBindings typeBindings0 = TypeBindings.create((Class<?>) class1, (List<JavaType>) vector0);
assertNotNull(typeBindings0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
PlaceholderForType placeholderForType0 = new PlaceholderForType(2230);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
MapType mapType0 = MapType.construct((Class<?>) class0, typeBindings0, (JavaType) placeholderForType0, (JavaType[]) null, (JavaType) placeholderForType0, (JavaType) placeholderForType0);
assertNotNull(mapType0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isEnumType());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertEquals(0, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
ArrayType arrayType0 = ArrayType.construct((JavaType) mapType0, typeBindings0);
assertNotNull(arrayType0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isEnumType());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertEquals(0, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.isCollectionLikeType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isEnumType());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isJavaLangObject());
assertFalse(arrayType0.hasValueHandler());
assertTrue(arrayType0.isFinal());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.useStaticType());
DoubleNode doubleNode0 = DoubleNode.valueOf((-1.0));
assertNotNull(doubleNode0);
assertNull(doubleNode0.textValue());
assertTrue(doubleNode0.isDouble());
assertEquals(0, doubleNode0.size());
assertFalse(doubleNode0.isMissingNode());
assertTrue(doubleNode0.canConvertToInt());
assertEquals((-1L), doubleNode0.longValue());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.booleanValue());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isShort());
assertEquals((-1.0), doubleNode0.doubleValue(), 0.01);
assertEquals((-1), doubleNode0.intValue());
assertEquals((short) (-1), doubleNode0.shortValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigInteger());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isInt());
assertFalse(doubleNode0.isNaN());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isObject());
assertEquals((-1.0F), doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isLong());
assertTrue(doubleNode0.isEmpty());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertFalse(doubleNode0.isIntegralNumber());
ArrayType arrayType1 = arrayType0.withContentTypeHandler(doubleNode0);
assertTrue(arrayType1.equals((Object)arrayType0));
assertNotNull(arrayType1);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isEnumType());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertEquals(0, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.isCollectionLikeType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isEnumType());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isJavaLangObject());
assertFalse(arrayType0.hasValueHandler());
assertTrue(arrayType0.isFinal());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.useStaticType());
assertNull(doubleNode0.textValue());
assertTrue(doubleNode0.isDouble());
assertEquals(0, doubleNode0.size());
assertFalse(doubleNode0.isMissingNode());
assertTrue(doubleNode0.canConvertToInt());
assertEquals((-1L), doubleNode0.longValue());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.booleanValue());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isShort());
assertEquals((-1.0), doubleNode0.doubleValue(), 0.01);
assertEquals((-1), doubleNode0.intValue());
assertEquals((short) (-1), doubleNode0.shortValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigInteger());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isInt());
assertFalse(doubleNode0.isNaN());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isObject());
assertEquals((-1.0F), doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isLong());
assertTrue(doubleNode0.isEmpty());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(arrayType1.isConcrete());
assertFalse(arrayType1.isInterface());
assertFalse(arrayType1.isPrimitive());
assertTrue(arrayType1.isFinal());
assertFalse(arrayType1.isCollectionLikeType());
assertTrue(arrayType1.hasContentType());
assertTrue(arrayType1.isContainerType());
assertFalse(arrayType1.hasValueHandler());
assertFalse(arrayType1.isEnumType());
assertFalse(arrayType1.isMapLikeType());
assertFalse(arrayType1.isJavaLangObject());
assertTrue(arrayType1.hasHandlers());
assertTrue(arrayType1.isArrayType());
assertFalse(arrayType1.isAbstract());
assertFalse(arrayType1.useStaticType());
assertEquals(0, arrayType1.containedTypeCount());
assertNotSame(arrayType0, arrayType1);
assertNotSame(arrayType1, arrayType0);
IntNode intNode0 = new IntNode(1536);
assertNotNull(intNode0);
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isShort());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertEquals(1536.0F, intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.isInt());
assertNull(intNode0.textValue());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isMissingNode());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isDouble());
assertEquals(1536, intNode0.intValue());
assertFalse(intNode0.isBigDecimal());
assertEquals(0, intNode0.size());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals(1536L, intNode0.longValue());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isNaN());
assertEquals((short)1536, intNode0.shortValue());
assertEquals(1536.0, intNode0.doubleValue(), 0.01);
assertTrue(intNode0.isEmpty());
assertTrue(intNode0.canConvertToInt());
ArrayType arrayType2 = arrayType1.withValueHandler(intNode0);
assertTrue(arrayType0.equals((Object)arrayType1));
assertTrue(arrayType1.equals((Object)arrayType0));
assertTrue(arrayType2.equals((Object)arrayType1));
assertTrue(arrayType2.equals((Object)arrayType0));
assertNotNull(arrayType2);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isEnumType());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertEquals(0, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.isCollectionLikeType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isEnumType());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isJavaLangObject());
assertFalse(arrayType0.hasValueHandler());
assertTrue(arrayType0.isFinal());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.useStaticType());
assertNull(doubleNode0.textValue());
assertTrue(doubleNode0.isDouble());
assertEquals(0, doubleNode0.size());
assertFalse(doubleNode0.isMissingNode());
assertTrue(doubleNode0.canConvertToInt());
assertEquals((-1L), doubleNode0.longValue());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.booleanValue());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isShort());
assertEquals((-1.0), doubleNode0.doubleValue(), 0.01);
assertEquals((-1), doubleNode0.intValue());
assertEquals((short) (-1), doubleNode0.shortValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigInteger());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isInt());
assertFalse(doubleNode0.isNaN());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isObject());
assertEquals((-1.0F), doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isLong());
assertTrue(doubleNode0.isEmpty());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(arrayType1.isConcrete());
assertFalse(arrayType1.isInterface());
assertFalse(arrayType1.isPrimitive());
assertTrue(arrayType1.isFinal());
assertFalse(arrayType1.isCollectionLikeType());
assertTrue(arrayType1.hasContentType());
assertTrue(arrayType1.isContainerType());
assertFalse(arrayType1.hasValueHandler());
assertFalse(arrayType1.isEnumType());
assertFalse(arrayType1.isMapLikeType());
assertFalse(arrayType1.isJavaLangObject());
assertTrue(arrayType1.hasHandlers());
assertTrue(arrayType1.isArrayType());
assertFalse(arrayType1.isAbstract());
assertFalse(arrayType1.useStaticType());
assertEquals(0, arrayType1.containedTypeCount());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isShort());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertEquals(1536.0F, intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isObject());
assertTrue(intNode0.isIntegralNumber());
assertTrue(intNode0.isInt());
assertNull(intNode0.textValue());
assertTrue(intNode0.canConvertToLong());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertFalse(intNode0.isMissingNode());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isDouble());
assertEquals(1536, intNode0.intValue());
assertFalse(intNode0.isBigDecimal());
assertEquals(0, intNode0.size());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals(1536L, intNode0.longValue());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isBigInteger());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isNaN());
assertEquals((short)1536, intNode0.shortValue());
assertEquals(1536.0, intNode0.doubleValue(), 0.01);
assertTrue(intNode0.isEmpty());
assertTrue(intNode0.canConvertToInt());
assertFalse(arrayType2.isPrimitive());
assertTrue(arrayType2.hasContentType());
assertTrue(arrayType2.isFinal());
assertFalse(arrayType2.isJavaLangObject());
assertEquals(0, arrayType2.containedTypeCount());
assertTrue(arrayType2.hasHandlers());
assertFalse(arrayType2.useStaticType());
assertFalse(arrayType2.isAbstract());
assertTrue(arrayType2.isArrayType());
assertTrue(arrayType2.isContainerType());
assertTrue(arrayType2.isConcrete());
assertFalse(arrayType2.isCollectionLikeType());
assertFalse(arrayType2.isMapLikeType());
assertFalse(arrayType2.isInterface());
assertFalse(arrayType2.isEnumType());
assertTrue(arrayType2.hasValueHandler());
assertNotSame(arrayType0, arrayType2);
assertNotSame(arrayType0, arrayType1);
assertNotSame(arrayType1, arrayType2);
assertNotSame(arrayType1, arrayType0);
assertNotSame(arrayType2, arrayType1);
assertNotSame(arrayType2, arrayType0);
// Undeclared exception!
try {
objectReader0.withType((JavaType) arrayType2);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// com.fasterxml.jackson.databind.node.DoubleNode cannot be cast to com.fasterxml.jackson.databind.jsontype.TypeDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test070() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getPort());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
char[] charArray0 = new char[8];
charArray0[0] = '{';
charArray0[1] = '3';
charArray0[2] = '+';
charArray0[3] = '>';
charArray0[4] = 'V';
charArray0[5] = '\\';
charArray0[6] = '$';
charArray0[7] = '3';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory2.createParser(charArray0);
assertArrayEquals(new char[] {'{', '3', '+', '>', 'V', '\\', '$', '3'}, charArray0);
assertEquals(8, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(8195, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
MappingIterator<PlaceholderForType> mappingIterator0 = objectReader1._bindAndReadValues((JsonParser) readerBasedJsonParser0);
assertArrayEquals(new char[] {'{', '3', '+', '>', 'V', '\\', '$', '3'}, charArray0);
assertEquals(8, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(8195, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
}
@Test(timeout = 4000)
public void test071() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getUserInfo());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getRef());
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, objectMapper0, true);
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
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, 1, pipedReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideFormatFeatures(0, (-1));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
ClassLoader classLoader0 = ClassLoader.getSystemClassLoader();
assertNotNull(classLoader0);
TypeFactory typeFactory1 = typeFactory0.withClassLoader(classLoader0);
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(typeFactory1);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
Class<Map> class0 = Map.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isInterface());
CollectionLikeType collectionLikeType0 = CollectionLikeType.upgradeFrom(simpleType0, simpleType0);
assertNotNull(collectionLikeType0);
assertFalse(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isInterface());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isAbstract());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertTrue(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isEnumType());
assertFalse(collectionLikeType0.isJavaLangObject());
assertFalse(collectionLikeType0.hasValueHandler());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isConcrete());
MapType mapType0 = typeFactory1.constructMapType((Class<? extends Map>) class0, (JavaType) collectionLikeType0, (JavaType) simpleType0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(mapType0);
assertFalse(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isInterface());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isAbstract());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertTrue(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isEnumType());
assertFalse(collectionLikeType0.isJavaLangObject());
assertFalse(collectionLikeType0.hasValueHandler());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isConcrete());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.hasContentType());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isEnumType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.useStaticType());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0);
assertNotNull(objectNode0);
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
Double double0 = new Double(1.0);
assertEquals(1.0, (double)double0, 0.01);
assertNotNull(double0);
ObjectNode objectNode1 = objectNode0.put("4m1HqN@T^BpwM::R&fg", double0);
assertNotNull(objectNode1);
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isFloat());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertEquals("", objectNode1.asText());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isMissingNode());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectNode1.put("4m1HqN@T^BpwM::R&fg", (-3232.746011750778));
assertNotNull(objectNode2);
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isFloat());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertEquals("", objectNode1.asText());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isDouble());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals(1, objectNode2.size());
assertFalse(objectNode2.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.booleanValue());
assertSame(objectNode0, objectNode2);
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
assertSame(objectNode2, objectNode1);
assertSame(objectNode2, objectNode0);
MapType mapType1 = (MapType)mapType0.withContentValueHandler(objectNode2);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertTrue(mapType1.equals((Object)mapType0));
assertNotNull(mapType1);
assertEquals("", objectNode0.asText());
assertNull(objectNode0.textValue());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isEmpty());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isFloat());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertEquals("", objectNode1.asText());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode2.isEmpty());
assertNull(objectNode2.numberType());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isDouble());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isBigInteger());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals(1, objectNode2.size());
assertFalse(objectNode2.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.booleanValue());
assertFalse(mapType1.useStaticType());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.isPrimitive());
assertFalse(mapType1.isJavaLangObject());
assertFalse(mapType1.isArrayType());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isCollectionLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.hasContentType());
assertTrue(mapType1.hasHandlers());
assertFalse(mapType1.isConcrete());
assertTrue(mapType1.isInterface());
assertTrue(mapType1.isMapLikeType());
assertFalse(mapType1.isFinal());
assertFalse(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isInterface());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isAbstract());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertTrue(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isEnumType());
assertFalse(collectionLikeType0.isJavaLangObject());
assertFalse(collectionLikeType0.hasValueHandler());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isConcrete());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.hasContentType());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isEnumType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.useStaticType());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
assertNotSame(mapType0, mapType1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
assertSame(objectNode1, objectNode2);
assertSame(objectNode2, objectNode1);
assertSame(objectNode2, objectNode0);
assertNotSame(mapType1, mapType0);
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1, (ResolvedType) mapType1);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// com.fasterxml.jackson.databind.node.ObjectNode cannot be cast to com.fasterxml.jackson.databind.JsonDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test072() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withValueToUpdate(objectMapper0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
Class<ObjectReader> class0 = ObjectReader.class;
// Undeclared exception!
try {
objectReader1.forType(class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test073() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getPort());
assertEquals("some", uRL0.getAuthority());
assertNull(uRL0.getQuery());
assertEquals("file", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
SimpleValueInstantiators simpleValueInstantiators0 = new SimpleValueInstantiators();
assertNotNull(simpleValueInstantiators0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withValueInstantiators(simpleValueInstantiators0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
SimpleDeserializers simpleDeserializers0 = new SimpleDeserializers();
assertNotNull(simpleDeserializers0);
DeserializerFactory deserializerFactory1 = beanDeserializerFactory0.withAdditionalDeserializers(simpleDeserializers0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory1);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory1);
assertNotSame(deserializerFactory1, deserializerFactory0);
assertNotSame(deserializerFactory1, beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(deserializerFactory1);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory1));
assertFalse(deserializerFactory0.equals((Object)deserializerFactory1));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory1);
assertNotSame(deserializerFactory0, deserializerFactory1);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory1, deserializerFactory0);
assertNotSame(deserializerFactory1, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonGenerator_Feature1);
assertFalse(jsonGenerator_Feature1.equals((Object)jsonGenerator_Feature0));
assertFalse(jsonGenerator_Feature0.equals((Object)jsonGenerator_Feature1));
assertNotNull(jsonFactory3);
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(61, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(61, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(61, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(61, jsonFactory2.getGeneratorFeatures());
assertNotSame(jsonGenerator_Feature1, jsonGenerator_Feature0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonGenerator_Feature0, jsonGenerator_Feature1);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
char[] charArray0 = new char[4];
charArray0[0] = '.';
charArray0[1] = 'l';
charArray0[2] = '&';
charArray0[3] = '<';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory3.createParser(charArray0);
assertArrayEquals(new char[] {'.', 'l', '&', '<'}, charArray0);
assertEquals(4, charArray0.length);
assertFalse(jsonGenerator_Feature1.equals((Object)jsonGenerator_Feature0));
assertFalse(jsonGenerator_Feature0.equals((Object)jsonGenerator_Feature1));
assertNotNull(readerBasedJsonParser0);
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(61, jsonFactory3.getGeneratorFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(61, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(61, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(61, jsonFactory2.getGeneratorFeatures());
assertNotSame(jsonGenerator_Feature1, jsonGenerator_Feature0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonGenerator_Feature0, jsonGenerator_Feature1);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
try {
objectReader0._initForReading(defaultDeserializationContext0, readerBasedJsonParser0);
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: (char[])\".l&<\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test074() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders((ObjectReader[]) null);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(1);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.INCONCLUSIVE;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
// Undeclared exception!
try {
objectReader0._reportUnkownFormat(dataFormatReaders2, (DataFormatReaders.Match) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test075() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertNotNull(fileDescriptor0);
assertFalse(fileDescriptor0.valid());
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
DataInputStream dataInputStream0 = new DataInputStream(mockFileInputStream0);
assertNotNull(dataInputStream0);
assertFalse(fileDescriptor0.valid());
try {
objectReader1.readValue((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.io.DataInputStream with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test076() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectMapper0.reader();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
Class<BooleanNode> class0 = BooleanNode.class;
ObjectReader objectReader2 = objectMapper0.readerFor(class0);
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
ClassLoader classLoader0 = ClassLoader.getSystemClassLoader();
assertNotNull(classLoader0);
TypeFactory typeFactory1 = typeFactory0.withClassLoader(classLoader0);
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(typeFactory1);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
LRUMap<Object, JavaType> lRUMap0 = new LRUMap<Object, JavaType>(3826, 1);
assertNotNull(lRUMap0);
TypeFactory typeFactory2 = typeFactory1.withCache(lRUMap0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertFalse(typeFactory2.equals((Object)typeFactory0));
assertFalse(typeFactory2.equals((Object)typeFactory1));
assertNotNull(typeFactory2);
assertNotSame(typeFactory0, typeFactory2);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
assertNotSame(typeFactory1, typeFactory2);
assertNotSame(typeFactory2, typeFactory0);
assertNotSame(typeFactory2, typeFactory1);
Class<Map> class1 = Map.class;
MapType mapType0 = typeFactory2.constructRawMapType(class1);
assertFalse(typeFactory0.equals((Object)typeFactory2));
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertFalse(typeFactory1.equals((Object)typeFactory2));
assertFalse(typeFactory2.equals((Object)typeFactory0));
assertFalse(typeFactory2.equals((Object)typeFactory1));
assertNotNull(mapType0);
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.isAbstract());
assertNotSame(typeFactory0, typeFactory2);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
assertNotSame(typeFactory1, typeFactory2);
assertNotSame(typeFactory2, typeFactory0);
assertNotSame(typeFactory2, typeFactory1);
MapperFeature mapperFeature0 = MapperFeature.AUTO_DETECT_GETTERS;
assertEquals(MapperFeature.AUTO_DETECT_GETTERS, mapperFeature0);
assertEquals(32, mapperFeature0.getMask());
assertTrue(mapperFeature0.enabledByDefault());
MapType mapType1 = mapType0.withContentValueHandler(mapperFeature0);
assertFalse(typeFactory0.equals((Object)typeFactory2));
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertFalse(typeFactory1.equals((Object)typeFactory2));
assertFalse(typeFactory2.equals((Object)typeFactory0));
assertFalse(typeFactory2.equals((Object)typeFactory1));
assertTrue(mapType1.equals((Object)mapType0));
assertNotNull(mapType1);
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.isAbstract());
assertEquals(32, mapperFeature0.getMask());
assertTrue(mapperFeature0.enabledByDefault());
assertFalse(mapType1.isArrayType());
assertFalse(mapType1.isFinal());
assertTrue(mapType1.isInterface());
assertFalse(mapType1.useStaticType());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasValueHandler());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isPrimitive());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.isMapLikeType());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.hasHandlers());
assertNotSame(typeFactory0, typeFactory2);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
assertNotSame(typeFactory1, typeFactory2);
assertNotSame(typeFactory2, typeFactory0);
assertNotSame(typeFactory2, typeFactory1);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
ObjectReader objectReader3 = objectReader2.withValueToUpdate(mapType1);
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(typeFactory0.equals((Object)typeFactory2));
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertFalse(typeFactory1.equals((Object)typeFactory2));
assertFalse(typeFactory2.equals((Object)typeFactory0));
assertFalse(typeFactory2.equals((Object)typeFactory1));
assertTrue(mapType0.equals((Object)mapType1));
assertTrue(mapType1.equals((Object)mapType0));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.isAbstract());
assertEquals(32, mapperFeature0.getMask());
assertTrue(mapperFeature0.enabledByDefault());
assertFalse(mapType1.isArrayType());
assertFalse(mapType1.isFinal());
assertTrue(mapType1.isInterface());
assertFalse(mapType1.useStaticType());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasValueHandler());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isPrimitive());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.isMapLikeType());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.hasHandlers());
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader0);
assertNotSame(typeFactory0, typeFactory2);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
assertNotSame(typeFactory1, typeFactory2);
assertNotSame(typeFactory2, typeFactory0);
assertNotSame(typeFactory2, typeFactory1);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
}
@Test(timeout = 4000)
public void test077() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[0];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 2151, 2151);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals((-2151), byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals((-2151), byteArrayInputStream0.available());
try {
objectReader0.readValue((DataInput) dataInputStream0);
fail("Expecting exception: EOFException");
} catch(EOFException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.DataInputStream", e);
}
}
@Test(timeout = 4000)
public void test078() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertNotNull(bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isInt());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isLong());
assertNull(booleanNode0.numberType());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigInteger());
assertEquals("true", booleanNode0.asText());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertTrue(booleanNode0.isEmpty());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isMissingNode());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isInt());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isLong());
assertNull(booleanNode0.numberType());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigInteger());
assertEquals("true", booleanNode0.asText());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertTrue(booleanNode0.isEmpty());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isMissingNode());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertEquals("", arrayNode0.asText());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isLong());
ObjectNode objectNode0 = arrayNode0.insertObject(0);
assertNotNull(objectNode0);
assertEquals("", arrayNode0.asText());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(1, arrayNode0.size());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isLong());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isShort());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isMissingNode());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
Short short0 = new Short((short)0);
assertEquals((short)0, (short)short0);
assertNotNull(short0);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) arrayNode0, class0);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// java.lang.String cannot be cast to com.fasterxml.jackson.databind.node.ObjectNode
//
verifyException("com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer$ObjectDeserializer", e);
}
}
@Test(timeout = 4000)
public void test079() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
Class<MissingNode> class0 = MissingNode.class;
ObjectReader objectReader0 = objectMapper1.readerWithView(class0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonNode jsonNode0 = objectReader0.createObjectNode();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isBigDecimal());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isIntegralNumber());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isBigDecimal());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isIntegralNumber());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasCurrentToken());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonNode jsonNode1 = objectReader0._bindAsTree(jsonParser0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertTrue(jsonNode1.equals((Object)jsonNode0));
assertNotNull(jsonNode1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isBigDecimal());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isIntegralNumber());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.END_OBJECT, jsonParser0.getCurrentToken());
assertEquals(2, jsonParser0.currentTokenId());
assertEquals(2, jsonParser0.getCurrentTokenId());
assertEquals(JsonToken.END_OBJECT, jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertTrue(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonNode1.isLong());
assertFalse(jsonNode1.isMissingNode());
assertNull(jsonNode1.textValue());
assertEquals(JsonToken.START_OBJECT, jsonNode1.asToken());
assertFalse(jsonNode1.isBigInteger());
assertFalse(jsonNode1.isShort());
assertTrue(jsonNode1.isObject());
assertEquals(0, jsonNode1.size());
assertFalse(jsonNode1.isInt());
assertFalse(jsonNode1.isIntegralNumber());
assertFalse(jsonNode1.isBigDecimal());
assertTrue(jsonNode1.isEmpty());
assertNull(jsonNode1.numberType());
assertFalse(jsonNode1.booleanValue());
assertEquals(JsonNodeType.OBJECT, jsonNode1.getNodeType());
assertFalse(jsonNode1.isFloat());
assertEquals("", jsonNode1.asText());
assertFalse(jsonNode1.isArray());
assertFalse(jsonNode1.isFloatingPointNumber());
assertFalse(jsonNode1.isDouble());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(jsonNode0, jsonNode1);
assertNotSame(jsonNode1, jsonNode0);
ObjectReader objectReader1 = objectReader0.withRootName("vvW/v\".FV6]w");
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
HashMap<String, Object> hashMap0 = new HashMap<String, Object>();
assertNotNull(hashMap0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(hashMap0);
assertNotNull(injectableValues_Std0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
ObjectReader objectReader2 = objectReader0.with((InjectableValues) injectableValues_Std0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
}
@Test(timeout = 4000)
public void test080() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0);
assertNotNull(objectNode0);
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isLong());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
ArrayNode arrayNode0 = objectNode0.putArray("_IFs>dw$");
assertNotNull(arrayNode0);
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isLong());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
NullNode nullNode0 = arrayNode0.nullNode();
assertNotNull(nullNode0);
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isLong());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(nullNode0.isBigInteger());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertEquals("null", nullNode0.asText());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertFalse(nullNode0.isInt());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isIntegralNumber());
Class<ObjectNode> class0 = ObjectNode.class;
ObjectNode objectNode1 = objectReader0.treeToValue((TreeNode) nullNode0, class0);
assertNull(objectNode1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isLong());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(nullNode0.isBigInteger());
assertTrue(nullNode0.isEmpty());
assertFalse(nullNode0.isBigDecimal());
assertEquals(JsonNodeType.NULL, nullNode0.getNodeType());
assertEquals("null", nullNode0.asText());
assertNull(nullNode0.numberType());
assertFalse(nullNode0.isObject());
assertNull(nullNode0.textValue());
assertFalse(nullNode0.isShort());
assertFalse(nullNode0.isInt());
assertEquals(JsonToken.VALUE_NULL, nullNode0.asToken());
assertFalse(nullNode0.isLong());
assertFalse(nullNode0.isMissingNode());
assertEquals(0, nullNode0.size());
assertFalse(nullNode0.booleanValue());
assertFalse(nullNode0.isArray());
assertFalse(nullNode0.isFloat());
assertFalse(nullNode0.isFloatingPointNumber());
assertFalse(nullNode0.isDouble());
assertFalse(nullNode0.isIntegralNumber());
JsonParser jsonParser0 = arrayNode0.traverse();
assertNotNull(jsonParser0);
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isMissingNode());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isLong());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
// Undeclared exception!
try {
objectReader0._bindAndReadValues(jsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test081() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[8];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[7] = objectReader0;
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(8, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte)32;
byteArray0[1] = (byte) (-54);
byteArray0[2] = (byte) (-54);
byteArray0[3] = (byte) (-50);
// Undeclared exception!
try {
objectReader1._detectBindAndClose(byteArray0, (-3019), 1583);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -3019
//
verifyException("com.fasterxml.jackson.core.format.InputAccessor$Std", e);
}
}
@Test(timeout = 4000)
public void test082() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
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, objectReader0, false);
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
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);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3451, pipedReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3451, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
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);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3579, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(3579, readerBasedJsonParser1.getFeatureMask());
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());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
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);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) readerBasedJsonParser1, (ResolvedType) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test083() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_TRAILING_COMMA;
// Undeclared exception!
try {
objectReader1.without(jsonParser_Feature0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test084() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isDouble());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isFloat());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isDouble());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isFloat());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
ObjectNode objectNode0 = arrayNode0.insertObject(0);
assertNotNull(objectNode0);
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertEquals(1, arrayNode0.size());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isFloat());
assertNull(objectNode0.numberType());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals("", objectNode0.asText());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isBigInteger());
MockFile mockFile0 = new MockFile("><dRw}mzyy");
assertNotNull(mockFile0);
boolean boolean1 = mockFile0.setLastModified(1);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
assertFalse(mockFile0.exists());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertFalse(mockFile0.isHidden());
assertEquals(0L, mockFile0.length());
assertEquals("><dRw}mzyy", mockFile0.toString());
assertFalse(mockFile0.isAbsolute());
assertEquals(0L, mockFile0.lastModified());
assertFalse(mockFile0.isDirectory());
assertFalse(mockFile0.canRead());
assertFalse(mockFile0.canExecute());
assertFalse(mockFile0.canWrite());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals("><dRw}mzyy", mockFile0.getName());
assertNull(mockFile0.getParent());
assertTrue(mockFile0.isFile());
URL uRL0 = mockFile0.toURL();
assertNotNull(uRL0);
assertFalse(mockFile0.exists());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertFalse(mockFile0.isHidden());
assertEquals(0L, mockFile0.length());
assertEquals("><dRw}mzyy", mockFile0.toString());
assertFalse(mockFile0.isAbsolute());
assertEquals(0L, mockFile0.lastModified());
assertFalse(mockFile0.isDirectory());
assertFalse(mockFile0.canRead());
assertFalse(mockFile0.canExecute());
assertFalse(mockFile0.canWrite());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals("><dRw}mzyy", mockFile0.getName());
assertNull(mockFile0.getParent());
assertTrue(mockFile0.isFile());
assertEquals("", uRL0.getHost());
assertNull(uRL0.getQuery());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getAuthority());
assertNull(uRL0.getUserInfo());
try {
objectReader0.readValue(uRL0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test085() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("file", uRL0.getProtocol());
assertEquals("some", uRL0.getAuthority());
assertEquals("some", uRL0.getHost());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
File file0 = MockFile.createTempFile("YC:F)!cg6FKKs=_j", "YC:F)!cg6FKKs=_j", (File) null);
assertNotNull(file0);
assertEquals("/tmp/YC:F)!cg6FKKs=_j0YC:F)!cg6FKKs=_j", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals("YC:F)!cg6FKKs=_j0YC:F)!cg6FKKs=_j", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
try {
objectReader1.readValue(file0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test086() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, class0, false);
assertNotNull(iOContext0);
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(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);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
PipedReader pipedReader0 = new PipedReader(1);
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2060));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, pipedReader0, objectMapper0, charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
Class<Map> class1 = Map.class;
MapType mapType0 = typeFactory0.constructRawMapType(class1);
assertNotNull(mapType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.useStaticType());
boolean boolean1 = readerBasedJsonParser0.getValueAsBoolean(false);
assertFalse(boolean1);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(boolean1 == boolean0);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
MapLikeType mapLikeType0 = mapType0.withStaticTyping();
assertTrue(mapLikeType0.equals((Object)mapType0));
assertNotNull(mapLikeType0);
assertEquals(2, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.hasValueHandler());
assertTrue(mapLikeType0.useStaticType());
assertFalse(mapLikeType0.isEnumType());
assertFalse(mapLikeType0.isJavaLangObject());
assertTrue(mapLikeType0.isInterface());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isConcrete());
assertTrue(mapLikeType0.hasContentType());
assertTrue(mapLikeType0.isMapLikeType());
assertFalse(mapLikeType0.hasHandlers());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.isAbstract());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.useStaticType());
assertNotSame(mapLikeType0, mapType0);
assertNotSame(mapType0, mapLikeType0);
Iterator<ArrayNode> iterator0 = objectReader0.readValues((JsonParser) readerBasedJsonParser0, (JavaType) mapLikeType0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(mapType0.equals((Object)mapLikeType0));
assertTrue(mapLikeType0.equals((Object)mapType0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(mapType0.isPrimitive());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isFinal());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.isMapLikeType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.useStaticType());
assertEquals(2, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.hasValueHandler());
assertTrue(mapLikeType0.useStaticType());
assertFalse(mapLikeType0.isEnumType());
assertFalse(mapLikeType0.isJavaLangObject());
assertTrue(mapLikeType0.isInterface());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isConcrete());
assertTrue(mapLikeType0.hasContentType());
assertTrue(mapLikeType0.isMapLikeType());
assertFalse(mapLikeType0.hasHandlers());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isArrayType());
assertTrue(mapLikeType0.isAbstract());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(mapType0, mapLikeType0);
assertNotSame(mapLikeType0, mapType0);
HashMap<String, Object> hashMap0 = new HashMap<String, Object>();
assertNotNull(hashMap0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
BiFunction<Object, Object, MissingNode> biFunction0 = (BiFunction<Object, Object, MissingNode>) mock(BiFunction.class, new ViolatedAssumptionAnswer());
Object object0 = hashMap0.computeIfPresent("8!G%z!}cZRm1L", biFunction0);
assertNull(object0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(hashMap0);
assertNotNull(injectableValues_Std0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((String) null, (Object) objectReader0);
assertNotNull(injectableValues_Std1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(hashMap0.isEmpty());
assertEquals(1, hashMap0.size());
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
InjectableValues.Std injectableValues_Std2 = injectableValues_Std1.addValue((Class<?>) class1, (Object) readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(injectableValues_Std2);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(hashMap0.isEmpty());
assertEquals(2, hashMap0.size());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertSame(injectableValues_Std2, injectableValues_Std1);
assertSame(injectableValues_Std2, injectableValues_Std0);
ObjectReader objectReader1 = objectReader0.with((InjectableValues) injectableValues_Std2);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(hashMap0.isEmpty());
assertEquals(2, hashMap0.size());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(objectReader0, objectReader1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertSame(injectableValues_Std2, injectableValues_Std1);
assertSame(injectableValues_Std2, injectableValues_Std0);
assertNotSame(objectReader1, objectReader0);
Class<ArrayNode> class2 = ArrayNode.class;
Iterator<ArrayNode> iterator1 = objectReader1.readValues((JsonParser) readerBasedJsonParser0, class2);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(iterator1.equals((Object)iterator0));
assertNotNull(iterator1);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(hashMap0.isEmpty());
assertEquals(2, hashMap0.size());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(objectReader0, objectReader1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std2);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertSame(injectableValues_Std2, injectableValues_Std1);
assertSame(injectableValues_Std2, injectableValues_Std0);
assertNotSame(objectReader1, objectReader0);
assertNotSame(iterator1, iterator0);
TypeReference<ObjectReader> typeReference0 = (TypeReference<ObjectReader>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) readerBasedJsonParser0, typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test087() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.without((FormatFeature) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test088() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertNotNull(fileDescriptor0);
assertFalse(fileDescriptor0.valid());
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
DataInputStream dataInputStream0 = new DataInputStream(mockFileInputStream0);
assertNotNull(dataInputStream0);
assertFalse(fileDescriptor0.valid());
try {
objectReader0.readValue((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.NativeMockedIO", e);
}
}
@Test(timeout = 4000)
public void test089() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
Class<ObjectNode> class0 = ObjectNode.class;
ArrayNode arrayNode0 = objectMapper0.createArrayNode();
assertNotNull(arrayNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
ObjectNode objectNode0 = arrayNode0.objectNode();
assertNotNull(objectNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isShort());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
LinkedList<String> linkedList0 = new LinkedList<String>();
assertNotNull(linkedList0);
assertEquals(0, linkedList0.size());
List<String> list0 = arrayNode0.findValuesAsText("J", (List<String>) linkedList0);
assertNotNull(list0);
assertFalse(linkedList0.contains("J"));
assertFalse(list0.contains("J"));
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(0, linkedList0.size());
assertTrue(list0.isEmpty());
assertEquals(0, list0.size());
ObjectNode objectNode1 = objectNode0.remove((Collection<String>) list0);
assertNotNull(objectNode1);
assertFalse(linkedList0.contains("J"));
assertFalse(list0.contains("J"));
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isShort());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertEquals(0, linkedList0.size());
assertTrue(list0.isEmpty());
assertEquals(0, list0.size());
assertEquals(0, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isBigInteger());
assertEquals("", objectNode1.asText());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isMissingNode());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
ObjectNode objectNode2 = objectReader0.treeToValue((TreeNode) objectNode1, class0);
assertTrue(objectNode2.equals((Object)objectNode0));
assertTrue(objectNode2.equals((Object)objectNode1));
assertNotNull(objectNode2);
assertFalse(linkedList0.contains("J"));
assertFalse(list0.contains("J"));
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isShort());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.booleanValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertEquals(0, linkedList0.size());
assertTrue(list0.isEmpty());
assertEquals(0, list0.size());
assertEquals(0, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isBigInteger());
assertEquals("", objectNode1.asText());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isLong());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode2.isFloatingPointNumber());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertNull(objectNode2.textValue());
assertFalse(objectNode2.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isInt());
assertFalse(objectNode2.booleanValue());
assertEquals(0, objectNode2.size());
assertFalse(objectNode2.isShort());
assertNull(objectNode2.numberType());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isBigDecimal());
assertTrue(objectNode2.isEmpty());
assertFalse(objectNode2.isIntegralNumber());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isDouble());
assertEquals("", objectNode2.asText());
assertFalse(objectNode2.isArray());
assertSame(objectNode0, objectNode1);
assertNotSame(objectNode0, objectNode2);
assertNotSame(objectNode1, objectNode2);
assertSame(objectNode1, objectNode0);
assertNotSame(objectNode2, objectNode1);
assertNotSame(objectNode2, objectNode0);
}
@Test(timeout = 4000)
public void test090() throws Throwable {
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory((DeserializerFactoryConfig) null);
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null, defaultSerializerProvider_Impl1, defaultDeserializationContext_Impl0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectReader objectReader0 = objectMapper1.reader((InjectableValues) injectableValues_Std0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
ObjectReader objectReader1 = objectReader0.with(jsonParser_Feature0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
InjectableValues injectableValues0 = objectReader1.getInjectableValues();
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(injectableValues0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(injectableValues_Std0, injectableValues0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(injectableValues0, injectableValues_Std0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader2 = objectReader0.without(deserializationFeature0, deserializationFeatureArray0);
assertEquals(1, deserializationFeatureArray0.length);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(injectableValues_Std0, injectableValues0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)98;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)26;
byteArray0[3] = (byte)14;
byteArray0[4] = (byte)121;
byteArray0[5] = (byte) (-55);
byteArray0[6] = (byte) (-96);
byteArray0[7] = (byte) (-114);
// Undeclared exception!
try {
objectReader2.readValue(byteArray0, (int) (-55), (-1057));
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test091() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)86;
byteArray0[1] = (byte) (-118);
byteArray0[2] = (byte)126;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)50;
byteArray0[6] = (byte)101;
byteArray0[7] = (byte) (-5);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, (byte) (-118), (byte)101);
assertArrayEquals(new byte[] {(byte)86, (byte) (-118), (byte)126, (byte)1, (byte)0, (byte)50, (byte)101, (byte) (-5)}, byteArray0);
assertEquals(8, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(101, byteArrayInputStream0.available());
// Undeclared exception!
try {
objectReader1._detectBindAndCloseAsTree(byteArrayInputStream0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.ByteArrayInputStream", e);
}
}
@Test(timeout = 4000)
public void test092() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)87;
byteArray0[2] = (byte) (-67);
byteArray0[3] = (byte) (-21);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)1, (byte)87, (byte) (-67), (byte) (-21)}, byteArray0);
assertEquals(4, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(4, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)1, (byte)87, (byte) (-67), (byte) (-21)}, byteArray0);
assertEquals(4, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(4, byteArrayInputStream0.available());
try {
objectReader0.readTree((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Invalid UTF-8 start byte 0xbd
// at [Source: (DataInputStream); line: 1, column: -1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test093() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
SimpleAbstractTypeResolver simpleAbstractTypeResolver0 = new SimpleAbstractTypeResolver();
assertNotNull(simpleAbstractTypeResolver0);
DeserializerFactoryConfig deserializerFactoryConfig1 = deserializerFactoryConfig0.withAbstractTypeResolver(simpleAbstractTypeResolver0);
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertNotNull(deserializerFactoryConfig1);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
assertNotSame(deserializerFactoryConfig0, deserializerFactoryConfig1);
assertNotSame(deserializerFactoryConfig1, deserializerFactoryConfig0);
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig1);
assertFalse(deserializerFactoryConfig0.equals((Object)deserializerFactoryConfig1));
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withDeserializerModifier(beanDeserializerModifier0);
assertFalse(deserializerFactoryConfig0.equals((Object)deserializerFactoryConfig1));
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
assertNotSame(deserializerFactoryConfig0, deserializerFactoryConfig1);
assertNotSame(deserializerFactoryConfig1, deserializerFactoryConfig0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.equals((Object)deserializerFactoryConfig1));
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DeserializerFactory deserializerFactory1 = beanDeserializerFactory0.withAbstractTypeResolver(simpleAbstractTypeResolver0);
assertFalse(deserializerFactoryConfig0.equals((Object)deserializerFactoryConfig1));
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory1);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
assertNotSame(deserializerFactoryConfig0, deserializerFactoryConfig1);
assertNotSame(deserializerFactoryConfig1, deserializerFactoryConfig0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory1);
assertNotSame(deserializerFactory1, deserializerFactory0);
assertNotSame(deserializerFactory1, beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(deserializerFactory1);
assertFalse(deserializerFactoryConfig0.equals((Object)deserializerFactoryConfig1));
assertFalse(deserializerFactoryConfig1.equals((Object)deserializerFactoryConfig0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory1));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)deserializerFactory1));
assertFalse(deserializerFactory1.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory1.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig1.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig1.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig1.hasValueInstantiators());
assertFalse(deserializerFactoryConfig1.hasDeserializers());
assertTrue(deserializerFactoryConfig1.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(deserializerFactoryConfig0, deserializerFactoryConfig1);
assertNotSame(deserializerFactoryConfig1, deserializerFactoryConfig0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory1);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(deserializerFactory0, deserializerFactory1);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory1, deserializerFactory0);
assertNotSame(deserializerFactory1, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, false, false);
assertFalse(boolean0);
// Undeclared exception!
try {
objectReader1.readValue((DataInput) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test094() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.readValue((DataInput) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test095() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
boolean boolean0 = true;
ObjectWriter objectWriter0 = objectMapper0.writer((CharacterEscapes) jsonpCharacterEscapes0);
assertNotNull(objectWriter0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectWriter0.hasPrefetchedSerializer());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory2 = jsonFactory0.setRootValueSeparator("JSON");
assertNotNull(jsonFactory2);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-100);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory2.createParser(byteArray0);
assertArrayEquals(new byte[] {(byte) (-100)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertNull(uTF8StreamJsonParser0.currentToken());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
try {
objectReader2._bindAsTree(uTF8StreamJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 156)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\uFFFD\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test096() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectMapper0.reader();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("some", uRL0.getHost());
assertNull(uRL0.getRef());
assertEquals("some", uRL0.getAuthority());
assertNull(uRL0.getQuery());
MockFile mockFile0 = new MockFile("com.fasterxml.jackson.databind.ObjectReader");
assertNotNull(mockFile0);
MockFile mockFile1 = new MockFile(mockFile0, "com.fasterxml.jackson.databind.ObjectReader");
assertFalse(mockFile1.equals((Object)mockFile0));
assertNotNull(mockFile1);
URL uRL1 = mockFile1.toURL();
assertFalse(mockFile0.equals((Object)mockFile1));
assertFalse(mockFile1.equals((Object)mockFile0));
assertFalse(uRL1.equals((Object)uRL0));
assertNotNull(uRL1);
assertFalse(mockFile0.canWrite());
assertEquals("com.fasterxml.jackson.databind.ObjectReader", mockFile0.getName());
assertFalse(mockFile0.canRead());
assertFalse(mockFile0.isAbsolute());
assertEquals(0L, mockFile0.getTotalSpace());
assertFalse(mockFile0.canExecute());
assertTrue(mockFile0.isFile());
assertEquals("com.fasterxml.jackson.databind.ObjectReader", mockFile0.toString());
assertFalse(mockFile0.exists());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.lastModified());
assertFalse(mockFile0.isHidden());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isDirectory());
assertFalse(mockFile1.exists());
assertEquals(0L, mockFile1.getFreeSpace());
assertFalse(mockFile1.isDirectory());
assertEquals("/experiment/com.fasterxml.jackson.databind.ObjectReader/com.fasterxml.jackson.databind.ObjectReader", mockFile1.toString());
assertFalse(mockFile1.canRead());
assertFalse(mockFile1.isHidden());
assertEquals(0L, mockFile1.getUsableSpace());
assertEquals("com.fasterxml.jackson.databind.ObjectReader", mockFile1.getName());
assertTrue(mockFile1.isAbsolute());
assertEquals("/experiment/com.fasterxml.jackson.databind.ObjectReader", mockFile1.getParent());
assertFalse(mockFile1.canWrite());
assertEquals(0L, mockFile1.lastModified());
assertTrue(mockFile1.isFile());
assertEquals(0L, mockFile1.getTotalSpace());
assertFalse(mockFile1.canExecute());
assertEquals(0L, mockFile1.length());
assertEquals("file", uRL1.getProtocol());
assertNull(uRL1.getRef());
assertEquals((-1), uRL1.getDefaultPort());
assertEquals("", uRL1.getHost());
assertNull(uRL1.getAuthority());
assertNull(uRL1.getQuery());
assertEquals((-1), uRL1.getPort());
assertNull(uRL1.getUserInfo());
assertNotSame(mockFile0, mockFile1);
assertNotSame(mockFile1, mockFile0);
assertNotSame(uRL1, uRL0);
try {
objectReader0.readValues(uRL1);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test097() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
try {
objectReader1.readValues("*-,H@l_G1u");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.lang.String with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test098() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isAbstract());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
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, objectReader0, false);
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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("Cannot use source of type ");
assertNotNull(stringReader0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY;
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1566));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'U';
charArray0[1] = 'I';
charArray0[2] = 'B';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader1, charsToNameCanonicalizer1, charArray0, (-696), (-1), false);
assertArrayEquals(new char[] {'U', 'I', 'B'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
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);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertArrayEquals(new char[] {'U', 'I', 'B'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(129, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(129, readerBasedJsonParser1.getFeatureMask());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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());
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);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -696
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test099() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
ObjectReader objectReader0 = objectMapper0.readerForUpdating(uRL0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
Class<Map> class0 = Map.class;
TimeZone timeZone0 = TimeZone.getTimeZone("");
assertNotNull(timeZone0);
assertEquals("GMT", timeZone0.getID());
ObjectReader objectReader1 = objectReader0.with(timeZone0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
assertEquals("GMT", timeZone0.getID());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<ShortNode> class1 = ShortNode.class;
Class<BeanDeserializer> class2 = BeanDeserializer.class;
MapType mapType0 = typeFactory0.constructMapType(class0, class1, class2);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(mapType0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isMapLikeType());
assertEquals(2, mapType0.containedTypeCount());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.isConcrete());
assertNotSame(objectReader0, objectReader1);
MapType mapType1 = mapType0.withStaticTyping();
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(mapType1.equals((Object)mapType0));
assertNotNull(mapType1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getHost());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isMapLikeType());
assertEquals(2, mapType0.containedTypeCount());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isCollectionLikeType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.useStaticType());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.isFinal());
assertFalse(mapType0.isConcrete());
assertTrue(mapType1.useStaticType());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isCollectionLikeType());
assertTrue(mapType1.isInterface());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.isFinal());
assertFalse(mapType1.isArrayType());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertEquals(2, mapType1.containedTypeCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) null, (JavaType) mapType1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test100() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ArrayDeque<ObjectReader> arrayDeque0 = new ArrayDeque<ObjectReader>();
assertNotNull(arrayDeque0);
assertFalse(arrayDeque0.contains(objectReader0));
assertEquals(0, arrayDeque0.size());
assertTrue(arrayDeque0.isEmpty());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(arrayDeque0);
assertNotNull(dataFormatReaders0);
assertFalse(arrayDeque0.contains(objectReader0));
assertEquals(0, arrayDeque0.size());
assertTrue(arrayDeque0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
MatchStrength matchStrength0 = MatchStrength.FULL_MATCH;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withOptimalMatch(matchStrength0);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(arrayDeque0.contains(objectReader0));
assertEquals(0, arrayDeque0.size());
assertTrue(arrayDeque0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)39;
byteArray0[1] = (byte)2;
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders1.findFormat(byteArray0);
assertArrayEquals(new byte[] {(byte)39, (byte)2}, byteArray0);
assertEquals(2, byteArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders_Match0);
assertFalse(arrayDeque0.contains(objectReader0));
assertEquals(0, arrayDeque0.size());
assertTrue(arrayDeque0.isEmpty());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
try {
objectReader1._detectBindAndClose(dataFormatReaders_Match0, false);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test101() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[2];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[0] = objectReader0;
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(2, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
// Undeclared exception!
try {
objectReader0.readValue((DataInput) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test102() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
// Undeclared exception!
try {
objectReader0.readValue((DataInput) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test103() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)98;
byteArray0[1] = (byte)98;
byteArray0[2] = (byte)48;
byteArray0[3] = (byte)117;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)1;
byteArray0[6] = (byte)90;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 1295, (-3747));
assertArrayEquals(new byte[] {(byte)98, (byte)98, (byte)48, (byte)117, (byte)0, (byte)1, (byte)90}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals((-3747), byteArrayInputStream0.available());
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory0.createParser((InputStream) byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)98, (byte)98, (byte)48, (byte)117, (byte)0, (byte)1, (byte)90}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals((-3747), byteArrayInputStream0.available());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser0.isNaN());
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isObject());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isLong());
assertTrue(missingNode0.isEmpty());
assertEquals(0, missingNode0.size());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.isFloatingPointNumber());
assertFalse(missingNode0.isFloat());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.isBigInteger());
assertFalse(missingNode0.isBigDecimal());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertEquals("", missingNode0.asText());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isShort());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = jsonFactory1._getBufferRecycler();
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(bufferRecycler0);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
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);
assertNotSame(jsonFactory1, jsonFactory0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory1.createParser(charArray0, 1536, 1536);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(jsonFactory1, jsonFactory0);
Class<BigIntegerNode> class0 = BigIntegerNode.class;
Iterator<BigIntegerNode> iterator0 = objectReader1.readValues((JsonParser) readerBasedJsonParser0, class0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, objectReaderArray0.length);
assertEquals(0, charArray0.length);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0._bindAndClose(readerBasedJsonParser0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1536
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test104() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
Class<CollectionType> class0 = CollectionType.class;
// Undeclared exception!
try {
objectReader1.withView(class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test105() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[6];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(6, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
int int0 = 9;
byte[] byteArray0 = new byte[5];
byte byte0 = (byte)2;
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
char[] charArray0 = new char[8];
charArray0[0] = 'w';
charArray0[1] = '~';
charArray0[2] = 'W';
charArray0[3] = 'f';
charArray0[4] = '3';
charArray0[5] = '9';
charArray0[6] = '-';
charArray0[7] = 'F';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(charArray0, (-1886), 9);
assertArrayEquals(new char[] {'w', '~', 'W', 'f', '3', '9', '-', 'F'}, charArray0);
assertEquals(8, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
// Undeclared exception!
try {
objectReader0._bindAndCloseAsTree(readerBasedJsonParser0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1886
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test106() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonFactory jsonFactory3 = jsonFactory2.setRootValueSeparator("f9a6g");
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertNotNull(jsonFactory3);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("f9a6g", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("f9a6g", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals("f9a6g", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(543, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl0.copy();
assertFalse(defaultSerializerProvider0.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider0);
assertNotSame(defaultSerializerProvider0, defaultSerializerProvider_Impl0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory3, defaultSerializerProvider0, defaultDeserializationContext_Impl0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider0));
assertFalse(defaultSerializerProvider0.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("f9a6g", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("f9a6g", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals("f9a6g", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(543, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_BIG_INTEGER_FOR_INTS;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider0));
assertFalse(defaultSerializerProvider0.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("f9a6g", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("f9a6g", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals("f9a6g", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(543, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider0);
assertNotSame(defaultSerializerProvider0, defaultSerializerProvider_Impl0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertNotNull(byteArrayOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
MockPrintStream mockPrintStream0 = new MockPrintStream(byteArrayOutputStream0);
assertNotNull(mockPrintStream0);
DataOutputStream dataOutputStream0 = new DataOutputStream(mockPrintStream0);
assertNotNull(dataOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
UTF8JsonGenerator uTF8JsonGenerator0 = (UTF8JsonGenerator)jsonFactory1.createGenerator((DataOutput) dataOutputStream0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(uTF8JsonGenerator0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(543, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("f9a6g", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
BooleanNode booleanNode0 = BooleanNode.getTrue();
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isShort());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertEquals("true", booleanNode0.asText());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
// Undeclared exception!
try {
objectReader0.writeTree(uTF8JsonGenerator0, booleanNode0);
fail("Expecting exception: UnsupportedOperationException");
} catch(UnsupportedOperationException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test107() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
IOContext iOContext0 = null;
int int0 = 1485;
// Undeclared exception!
try {
objectReader0._inputStream((File) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test108() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isShort());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
ArrayNode arrayNode0 = objectNode0.putArray("C6tNu>.[gNH");
assertNotNull(arrayNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isFloat());
JsonParser jsonParser0 = arrayNode0.traverse();
assertNotNull(jsonParser0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isFloat());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(0, jsonParser0.getFeatureMask());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(jsonParser0, tokenFilter0, false, true);
assertNotNull(filteringParserDelegate0);
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isFloat());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(0, jsonParser0.getFeatureMask());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.currentTokenId());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertNull(filteringParserDelegate0.currentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertFalse(filteringParserDelegate0.canParseAsync());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getMatchCount());
FilteringParserDelegate filteringParserDelegate1 = (FilteringParserDelegate)objectReader1._considerFilter(filteringParserDelegate0, true);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(filteringParserDelegate1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(concurrentHashMap0.isEmpty());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isFloat());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isDouble());
assertEquals("", arrayNode0.asText());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isMissingNode());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isFloat());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(0, jsonParser0.getFeatureMask());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.currentTokenId());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertNull(filteringParserDelegate0.currentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertFalse(filteringParserDelegate0.canParseAsync());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertEquals(0, filteringParserDelegate1.getFeatureMask());
assertFalse(filteringParserDelegate1.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate1.getFormatFeatures());
assertEquals(0, filteringParserDelegate1.getCurrentTokenId());
assertEquals(0, filteringParserDelegate1.currentTokenId());
assertFalse(filteringParserDelegate1.canReadObjectId());
assertFalse(filteringParserDelegate1.hasCurrentToken());
assertNull(filteringParserDelegate1.currentToken());
assertFalse(filteringParserDelegate1.requiresCustomCodec());
assertFalse(filteringParserDelegate1.canParseAsync());
assertNull(filteringParserDelegate1.getCurrentToken());
assertFalse(filteringParserDelegate1.isExpectedStartArrayToken());
assertFalse(filteringParserDelegate1.canReadTypeId());
assertNull(filteringParserDelegate1.getLastClearedToken());
assertEquals(0, filteringParserDelegate1.getMatchCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(filteringParserDelegate0, filteringParserDelegate1);
assertSame(filteringParserDelegate1, filteringParserDelegate0);
// Undeclared exception!
try {
objectReader1.readValue((File) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test109() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
SimpleMixInResolver simpleMixInResolver0 = objectMapper0._mixIns;
assertNotNull(simpleMixInResolver0);
assertEquals(0, simpleMixInResolver0.localSize());
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = objectMapper0._configOverrides;
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig((BaseSettings) null, stdSubtypeResolver0, simpleMixInResolver0, rootNameLookup0, configOverrides0);
assertNotNull(deserializationConfig0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
ObjectReader objectReader1 = new ObjectReader(objectReader0, deserializationConfig0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig0.getDefaultMergeable());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
LinkedHashSet<ObjectReader> linkedHashSet0 = new LinkedHashSet<ObjectReader>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(objectReader1));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedHashSet0);
assertNotNull(dataFormatReaders0);
assertFalse(linkedHashSet0.contains(objectReader1));
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, linkedHashSet0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
PipedOutputStream pipedOutputStream0 = null;
try {
pipedOutputStream0 = new PipedOutputStream((PipedInputStream) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.PipedOutputStream", e);
}
}
@Test(timeout = 4000)
public void test110() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null);
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = objectMapper0.setDefaultSetterInfo((JsonSetter.Value) null);
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectMapper0, objectMapper1);
HashMap<FloatNode, AbstractDeserializer> hashMap0 = new HashMap<FloatNode, AbstractDeserializer>();
assertNotNull(hashMap0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
ObjectReader objectReader1 = objectReader0.withAttributes(hashMap0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
assertSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<CollectionLikeType> class0 = CollectionLikeType.class;
// Undeclared exception!
try {
objectReader0.withType(class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder", e);
}
}
@Test(timeout = 4000)
public void test111() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getHost());
assertEquals("file", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getAuthority());
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)88;
// Undeclared exception!
try {
objectReader1.readValue(byteArray0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test112() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader1 = objectMapper1.reader(deserializationFeature0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
JsonNode jsonNode0 = objectReader0.readTree("");
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isFloat());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.booleanValue());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
// Undeclared exception!
try {
objectReader0._bindAsTree((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test113() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
ObjectReader objectReader1 = objectReader0.withoutRootName();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.with((Base64Variant) null);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
}
@Test(timeout = 4000)
public void test114() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[0];
JsonNode jsonNode0 = objectReader0.readTree(byteArray0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isArray());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(0, jsonNode0.size());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isLong());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isMissingNode());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isObject());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
assertNotNull(objectNode0);
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertNull(objectNode0.textValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.booleanValue());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
// Undeclared exception!
try {
objectReader0._findTreeDeserializer((DeserializationContext) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test115() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(charArray0, 1536, 1536);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
Iterator<BigIntegerNode> iterator0 = objectReader1.readValues((JsonParser) readerBasedJsonParser0, class0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, objectReaderArray0.length);
assertEquals(0, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideFormatFeatures(1536, 2432);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(8193, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
// Undeclared exception!
try {
objectReader0._bindAsTree(readerBasedJsonParser1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1536
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test116() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(charArray0, 1536, 1536);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
// Undeclared exception!
try {
objectReader1.readValues((JsonParser) readerBasedJsonParser0, class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test117() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(charArray0, 1536, 1536);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
Iterator<BigIntegerNode> iterator0 = objectReader1.readValues((JsonParser) readerBasedJsonParser0, class0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, objectReaderArray0.length);
assertEquals(0, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
PipedWriter pipedWriter0 = new PipedWriter();
assertNotNull(pipedWriter0);
PipedReader pipedReader0 = new PipedReader(pipedWriter0, 1536);
assertNotNull(pipedReader0);
try {
objectReader1.readValue((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.io.PipedReader with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test118() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
BaseSettings baseSettings0 = ObjectMapper.DEFAULT_BASE;
assertNotNull(baseSettings0);
assertFalse(baseSettings0.hasExplicitTimeZone());
LinkedList<Locale.LanguageRange> linkedList0 = new LinkedList<Locale.LanguageRange>();
assertNotNull(linkedList0);
assertEquals(0, linkedList0.size());
ArrayList<Locale> arrayList0 = new ArrayList<Locale>();
assertNotNull(arrayList0);
assertTrue(arrayList0.isEmpty());
assertEquals(0, arrayList0.size());
Locale locale0 = Locale.lookup(linkedList0, arrayList0);
assertNull(locale0);
assertEquals(0, linkedList0.size());
assertTrue(arrayList0.isEmpty());
assertEquals(0, arrayList0.size());
BaseSettings baseSettings1 = baseSettings0.with((Locale) null);
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertNotNull(baseSettings1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertNotSame(baseSettings0, baseSettings1);
assertNotSame(baseSettings1, baseSettings0);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
BaseSettings baseSettings2 = baseSettings1.withTypeFactory(typeFactory0);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertFalse(baseSettings2.equals((Object)baseSettings0));
assertNotNull(baseSettings2);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertFalse(baseSettings2.hasExplicitTimeZone());
assertNotSame(baseSettings0, baseSettings1);
assertNotSame(baseSettings0, baseSettings2);
assertSame(baseSettings1, baseSettings2);
assertNotSame(baseSettings1, baseSettings0);
assertNotSame(baseSettings2, baseSettings0);
assertSame(baseSettings2, baseSettings1);
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
SimpleMixInResolver simpleMixInResolver0 = objectMapper0._mixIns;
assertNotNull(simpleMixInResolver0);
assertEquals(0, simpleMixInResolver0.localSize());
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = objectMapper0._configOverrides;
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
SerializationConfig serializationConfig0 = new SerializationConfig(baseSettings2, stdSubtypeResolver0, simpleMixInResolver0, rootNameLookup0, configOverrides0);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings0.equals((Object)baseSettings2));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertFalse(baseSettings2.equals((Object)baseSettings0));
assertNotNull(serializationConfig0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertFalse(baseSettings2.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(0, serializationConfig0.mixInCount());
assertFalse(serializationConfig0.useRootWrapping());
assertFalse(serializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(2722236, serializationConfig0.getSerializationFeatures());
assertTrue(serializationConfig0.isAnnotationProcessingEnabled());
assertTrue(serializationConfig0.canOverrideAccessModifiers());
assertNull(serializationConfig0.getRootName());
assertEquals(JsonInclude.Include.ALWAYS, serializationConfig0.getSerializationInclusion());
assertNull(serializationConfig0.getDefaultMergeable());
ObjectWriter objectWriter0 = objectMapper0._newWriter(serializationConfig0);
assertFalse(baseSettings0.equals((Object)baseSettings1));
assertFalse(baseSettings0.equals((Object)baseSettings2));
assertFalse(baseSettings1.equals((Object)baseSettings0));
assertFalse(baseSettings2.equals((Object)baseSettings0));
assertNotNull(objectWriter0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertFalse(baseSettings1.hasExplicitTimeZone());
assertFalse(baseSettings2.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(0, serializationConfig0.mixInCount());
assertFalse(serializationConfig0.useRootWrapping());
assertFalse(serializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(2722236, serializationConfig0.getSerializationFeatures());
assertTrue(serializationConfig0.isAnnotationProcessingEnabled());
assertTrue(serializationConfig0.canOverrideAccessModifiers());
assertNull(serializationConfig0.getRootName());
assertEquals(JsonInclude.Include.ALWAYS, serializationConfig0.getSerializationInclusion());
assertNull(serializationConfig0.getDefaultMergeable());
assertFalse(objectWriter0.hasPrefetchedSerializer());
assertNotSame(baseSettings0, baseSettings1);
assertNotSame(baseSettings0, baseSettings2);
assertSame(baseSettings1, baseSettings2);
assertNotSame(baseSettings1, baseSettings0);
assertNotSame(baseSettings2, baseSettings0);
assertSame(baseSettings2, baseSettings1);
MockFile mockFile0 = new MockFile("\":PI:Y6*POR", "\":PI:Y6*POR");
assertNotNull(mockFile0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
// Undeclared exception!
try {
objectReader1.withoutRootName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test119() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonParser_Feature0);
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
char[] charArray0 = new char[2];
charArray0[0] = '|';
charArray0[1] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory2.createParser(charArray0, (-3665), (-3665));
assertArrayEquals(new char[] {'|', '4'}, charArray0);
assertEquals(2, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
Class<List> class0 = List.class;
CollectionType collectionType0 = typeFactory0.constructRawCollectionType(class0);
assertNotNull(collectionType0);
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isContainerType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.useStaticType());
assertEquals(1, collectionType0.containedTypeCount());
DoubleNode doubleNode0 = DoubleNode.valueOf(846.132655465244);
assertNotNull(doubleNode0);
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isIntegralNumber());
assertFalse(doubleNode0.booleanValue());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isMissingNode());
assertEquals(846, doubleNode0.intValue());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isBigInteger());
assertTrue(doubleNode0.canConvertToInt());
assertTrue(doubleNode0.isDouble());
assertEquals(846L, doubleNode0.longValue());
assertEquals(0, doubleNode0.size());
assertEquals((short)846, doubleNode0.shortValue());
assertFalse(doubleNode0.isObject());
assertFalse(doubleNode0.isInt());
assertEquals(846.132655465244, doubleNode0.doubleValue(), 0.01);
assertEquals(846.1326F, doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isShort());
assertNull(doubleNode0.textValue());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertTrue(doubleNode0.isEmpty());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isLong());
CollectionType collectionType1 = collectionType0.withContentValueHandler(doubleNode0);
assertTrue(collectionType1.equals((Object)collectionType0));
assertNotNull(collectionType1);
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isContainerType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.useStaticType());
assertEquals(1, collectionType0.containedTypeCount());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isIntegralNumber());
assertFalse(doubleNode0.booleanValue());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isMissingNode());
assertEquals(846, doubleNode0.intValue());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isBigInteger());
assertTrue(doubleNode0.canConvertToInt());
assertTrue(doubleNode0.isDouble());
assertEquals(846L, doubleNode0.longValue());
assertEquals(0, doubleNode0.size());
assertEquals((short)846, doubleNode0.shortValue());
assertFalse(doubleNode0.isObject());
assertFalse(doubleNode0.isInt());
assertEquals(846.132655465244, doubleNode0.doubleValue(), 0.01);
assertEquals(846.1326F, doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isShort());
assertNull(doubleNode0.textValue());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertTrue(doubleNode0.isEmpty());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isLong());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isEnumType());
assertFalse(collectionType1.isMapLikeType());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isPrimitive());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.useStaticType());
assertTrue(collectionType1.hasHandlers());
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType0);
LinkedList<PropertyName> linkedList0 = new LinkedList<PropertyName>();
assertNotNull(linkedList0);
assertEquals(0, linkedList0.size());
CollectionType collectionType2 = collectionType1.withValueHandler(linkedList0);
assertTrue(collectionType2.equals((Object)collectionType1));
assertTrue(collectionType2.equals((Object)collectionType0));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType1.equals((Object)collectionType0));
assertNotNull(collectionType2);
assertEquals(0, linkedList0.size());
assertTrue(collectionType2.isAbstract());
assertTrue(collectionType2.hasHandlers());
assertFalse(collectionType2.isConcrete());
assertTrue(collectionType2.isCollectionLikeType());
assertFalse(collectionType2.isArrayType());
assertTrue(collectionType2.isContainerType());
assertEquals(1, collectionType2.containedTypeCount());
assertFalse(collectionType2.useStaticType());
assertFalse(collectionType2.isMapLikeType());
assertFalse(collectionType2.isJavaLangObject());
assertTrue(collectionType2.hasContentType());
assertFalse(collectionType2.isEnumType());
assertTrue(collectionType2.hasValueHandler());
assertFalse(collectionType2.isFinal());
assertFalse(collectionType2.isPrimitive());
assertTrue(collectionType2.isInterface());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isContainerType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.useStaticType());
assertEquals(1, collectionType0.containedTypeCount());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isIntegralNumber());
assertFalse(doubleNode0.booleanValue());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isMissingNode());
assertEquals(846, doubleNode0.intValue());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isBigInteger());
assertTrue(doubleNode0.canConvertToInt());
assertTrue(doubleNode0.isDouble());
assertEquals(846L, doubleNode0.longValue());
assertEquals(0, doubleNode0.size());
assertEquals((short)846, doubleNode0.shortValue());
assertFalse(doubleNode0.isObject());
assertFalse(doubleNode0.isInt());
assertEquals(846.132655465244, doubleNode0.doubleValue(), 0.01);
assertEquals(846.1326F, doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isShort());
assertNull(doubleNode0.textValue());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertTrue(doubleNode0.isEmpty());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isLong());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isEnumType());
assertFalse(collectionType1.isMapLikeType());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isPrimitive());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.useStaticType());
assertTrue(collectionType1.hasHandlers());
assertNotSame(collectionType2, collectionType1);
assertNotSame(collectionType2, collectionType0);
assertNotSame(collectionType0, collectionType2);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType1, collectionType2);
assertNotSame(collectionType1, collectionType0);
CollectionType collectionType3 = collectionType2.withTypeHandler((Object) null);
assertTrue(collectionType2.equals((Object)collectionType1));
assertTrue(collectionType2.equals((Object)collectionType0));
assertTrue(collectionType3.equals((Object)collectionType2));
assertTrue(collectionType3.equals((Object)collectionType1));
assertTrue(collectionType3.equals((Object)collectionType0));
assertTrue(collectionType0.equals((Object)collectionType1));
assertTrue(collectionType0.equals((Object)collectionType2));
assertTrue(collectionType1.equals((Object)collectionType0));
assertTrue(collectionType1.equals((Object)collectionType2));
assertNotNull(collectionType3);
assertEquals(0, linkedList0.size());
assertTrue(collectionType2.isAbstract());
assertTrue(collectionType2.hasHandlers());
assertFalse(collectionType2.isConcrete());
assertTrue(collectionType2.isCollectionLikeType());
assertFalse(collectionType2.isArrayType());
assertTrue(collectionType2.isContainerType());
assertEquals(1, collectionType2.containedTypeCount());
assertFalse(collectionType2.useStaticType());
assertFalse(collectionType2.isMapLikeType());
assertFalse(collectionType2.isJavaLangObject());
assertTrue(collectionType2.hasContentType());
assertFalse(collectionType2.isEnumType());
assertTrue(collectionType2.hasValueHandler());
assertFalse(collectionType2.isFinal());
assertFalse(collectionType2.isPrimitive());
assertTrue(collectionType2.isInterface());
assertFalse(collectionType3.isConcrete());
assertTrue(collectionType3.isCollectionLikeType());
assertTrue(collectionType3.isAbstract());
assertEquals(1, collectionType3.containedTypeCount());
assertTrue(collectionType3.hasHandlers());
assertFalse(collectionType3.isJavaLangObject());
assertFalse(collectionType3.useStaticType());
assertTrue(collectionType3.isInterface());
assertFalse(collectionType3.isMapLikeType());
assertFalse(collectionType3.isPrimitive());
assertTrue(collectionType3.isContainerType());
assertFalse(collectionType3.isArrayType());
assertFalse(collectionType3.isFinal());
assertTrue(collectionType3.hasContentType());
assertFalse(collectionType3.isEnumType());
assertTrue(collectionType3.hasValueHandler());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isConcrete());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isFinal());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.isContainerType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.hasHandlers());
assertFalse(collectionType0.useStaticType());
assertEquals(1, collectionType0.containedTypeCount());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isIntegralNumber());
assertFalse(doubleNode0.booleanValue());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isMissingNode());
assertEquals(846, doubleNode0.intValue());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isBigInteger());
assertTrue(doubleNode0.canConvertToInt());
assertTrue(doubleNode0.isDouble());
assertEquals(846L, doubleNode0.longValue());
assertEquals(0, doubleNode0.size());
assertEquals((short)846, doubleNode0.shortValue());
assertFalse(doubleNode0.isObject());
assertFalse(doubleNode0.isInt());
assertEquals(846.132655465244, doubleNode0.doubleValue(), 0.01);
assertEquals(846.1326F, doubleNode0.floatValue(), 0.01F);
assertFalse(doubleNode0.isShort());
assertNull(doubleNode0.textValue());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertTrue(doubleNode0.canConvertToLong());
assertTrue(doubleNode0.isEmpty());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isLong());
assertEquals(1, collectionType1.containedTypeCount());
assertFalse(collectionType1.hasValueHandler());
assertFalse(collectionType1.isEnumType());
assertFalse(collectionType1.isMapLikeType());
assertFalse(collectionType1.isJavaLangObject());
assertTrue(collectionType1.isInterface());
assertFalse(collectionType1.isConcrete());
assertTrue(collectionType1.hasContentType());
assertTrue(collectionType1.isCollectionLikeType());
assertFalse(collectionType1.isFinal());
assertTrue(collectionType1.isContainerType());
assertFalse(collectionType1.isPrimitive());
assertTrue(collectionType1.isAbstract());
assertFalse(collectionType1.isArrayType());
assertFalse(collectionType1.useStaticType());
assertTrue(collectionType1.hasHandlers());
assertNotSame(collectionType2, collectionType1);
assertNotSame(collectionType2, collectionType0);
assertNotSame(collectionType2, collectionType3);
assertNotSame(collectionType3, collectionType0);
assertNotSame(collectionType3, collectionType2);
assertNotSame(collectionType3, collectionType1);
assertNotSame(collectionType0, collectionType2);
assertNotSame(collectionType0, collectionType1);
assertNotSame(collectionType0, collectionType3);
assertNotSame(collectionType1, collectionType3);
assertNotSame(collectionType1, collectionType2);
assertNotSame(collectionType1, collectionType0);
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) readerBasedJsonParser0, (ResolvedType) collectionType3);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// com.fasterxml.jackson.databind.node.DoubleNode cannot be cast to com.fasterxml.jackson.databind.JsonDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test120() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectMapper0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectReader0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isAbstract());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertEquals(0, simpleType0.containedTypeCount());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
assertEquals(4, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isAbstract());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertEquals(0, simpleType0.containedTypeCount());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectReader1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
try {
objectReader0.readTree("-");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-inputNo digit following minus sign
// at [Source: (String)\"-\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test121() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
objectReader0._verifySchemaType((FormatSchema) null);
assertFalse(objectReader0.equals((Object)objectReader1));
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
// Undeclared exception!
try {
objectReader1.withHandler(deserializationProblemHandler0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test122() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
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);
char[] charArray0 = new char[3];
charArray0[1] = '/';
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertEquals(0, arrayNode0.size());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isShort());
assertNull(arrayNode0.textValue());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator("tQ|@KHU)Y|CpN`#8");
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("tQ|@KHU)Y|CpN`#8", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("tQ|@KHU)Y|CpN`#8", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory1);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("tQ|@KHU)Y|CpN`#8", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("tQ|@KHU)Y|CpN`#8", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
Class<List> class0 = List.class;
Class<Module> class1 = Module.class;
CollectionType collectionType0 = typeFactory0.constructCollectionType(class0, class1);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(collectionType0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(collectionType0.isInterface());
assertTrue(collectionType0.hasContentType());
assertFalse(collectionType0.useStaticType());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isFinal());
assertEquals(1, collectionType0.containedTypeCount());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.isConcrete());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.hasValueHandler());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isPrimitive());
assertNotSame(objectReader0, objectReader1);
try {
objectReader1._bind(readerBasedJsonParser0, collectionType0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'entries': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test123() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[5];
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(charArray0, 1536, 1536);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
Iterator<BigIntegerNode> iterator0 = objectReader1.readValues((JsonParser) readerBasedJsonParser0, class0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, objectReaderArray0.length);
assertEquals(0, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
try {
objectReader1._detectBindAndClose(byteArray0, 1, 3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test124() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0, 0);
assertNotNull(arrayNode0);
assertEquals("", arrayNode0.asText());
assertNull(arrayNode0.textValue());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.booleanValue());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isIntegralNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
JsonParser jsonParser0 = arrayNode0.traverse((ObjectCodec) objectMapper0);
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", arrayNode0.asText());
assertNull(arrayNode0.textValue());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.booleanValue());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isIntegralNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
JsonNode jsonNode0 = objectReader1._bindAsTree(jsonParser0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertTrue(jsonNode0.equals((Object)arrayNode0));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", arrayNode0.asText());
assertNull(arrayNode0.textValue());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.booleanValue());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isIntegralNumber());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.isClosed());
assertEquals(JsonToken.END_ARRAY, jsonParser0.getCurrentToken());
assertEquals(JsonToken.END_ARRAY, jsonParser0.currentToken());
assertTrue(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(4, jsonParser0.currentTokenId());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(4, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isInt());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isDouble());
assertTrue(jsonNode0.isArray());
assertEquals(0, jsonNode0.size());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals("", jsonNode0.asText());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(arrayNode0, jsonNode0);
assertNotSame(jsonNode0, arrayNode0);
try {
objectReader1._detectBindAndClose(byteArray0, 1, 3);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test125() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(pipedInputStream0);
assertNotNull(dataInputStream0);
assertEquals(0, pipedInputStream0.available());
try {
objectReader0.readTree((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedInputStream", e);
}
}
@Test(timeout = 4000)
public void test126() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory1 = jsonFactory0.copy();
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
ObjectReader[] objectReaderArray0 = new ObjectReader[8];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[7] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(8, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
assertEquals(8, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
PipedReader pipedReader0 = new PipedReader(64);
assertNotNull(pipedReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser((Reader) pipedReader0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertNotNull(readerBasedJsonParser0);
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(jsonFactory0, jsonFactory1);
try {
objectReader0._bindAsTree(readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test127() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.readValue((File) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test128() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte) (-26);
byteArray0[1] = (byte) (-101);
byteArray0[2] = (byte) (-24);
byteArray0[3] = (byte)50;
byteArray0[4] = (byte) (-22);
try {
objectReader1.readTree(byteArray0, 1168, (-1504));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type [B with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test129() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader[] objectReaderArray0 = new ObjectReader[9];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[8] = objectReader0;
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "qo7V+W$VT~bAZdkuGoY");
assertFalse(boolean0);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
Class<DoubleNode> class0 = DoubleNode.class;
Class<ArrayNode> class1 = ArrayNode.class;
MapLikeType mapLikeType0 = typeFactory0.constructMapLikeType(class0, class1, class1);
assertNotNull(mapLikeType0);
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.hasHandlers());
assertFalse(mapLikeType0.isFinal());
assertFalse(mapLikeType0.isPrimitive());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isInterface());
assertFalse(mapLikeType0.hasValueHandler());
assertEquals(0, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.useStaticType());
assertFalse(mapLikeType0.isArrayType());
// Undeclared exception!
try {
objectReader0.withType((JavaType) mapLikeType0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test130() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
try {
objectReader1.readValue((InputStream) pipedInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test131() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<AbstractDeserializer> class0 = AbstractDeserializer.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, true);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[4];
charArray0[0] = '2';
charArray0[1] = 'A';
charArray0[2] = 's';
charArray0[3] = 'y';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, pipedReader0, objectReader0, charsToNameCanonicalizer0, charArray0, 0, 33, true);
assertArrayEquals(new char[] {'2', 'A', 's', 'y'}, charArray0);
assertEquals(4, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.skipChildren();
assertArrayEquals(new char[] {'2', 'A', 's', 'y'}, charArray0);
assertEquals(4, charArray0.length);
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
try {
objectReader0._bindAndClose(readerBasedJsonParser1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('A' (code 65)): 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 test132() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[11];
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonParser.Feature jsonParser_Feature1 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature1);
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonParser_Feature1, jsonParser_Feature0);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory0.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory2);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonParser.Feature jsonParser_Feature2 = JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS;
JsonFactory jsonFactory3 = jsonFactory2.disable(jsonParser_Feature2);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature2));
assertFalse(jsonParser_Feature2.equals((Object)jsonParser_Feature1));
assertFalse(jsonParser_Feature2.equals((Object)jsonParser_Feature0));
assertNotNull(jsonFactory3);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(12289, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonParser_Feature0, jsonParser_Feature2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonParser_Feature2, jsonParser_Feature1);
assertNotSame(jsonParser_Feature2, jsonParser_Feature0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
JsonFactory jsonFactory4 = jsonFactory2.setCodec(objectMapper1);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory4);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertEquals(12289, jsonFactory4.getParserFeatures());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonParser_Feature0, jsonParser_Feature2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory0);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory3);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory5 = jsonFactory4.configure(jsonGenerator_Feature0, true);
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory5);
assertFalse(jsonFactory5.requiresCustomCodec());
assertEquals(0, jsonFactory5.getFormatParserFeatures());
assertEquals("JSON", jsonFactory5.getFormatName());
assertFalse(jsonFactory5.canHandleBinaryNatively());
assertTrue(jsonFactory5.canUseCharArrays());
assertEquals(12289, jsonFactory5.getParserFeatures());
assertEquals(" ", jsonFactory5.getRootValueSeparator());
assertEquals(543, jsonFactory5.getGeneratorFeatures());
assertFalse(jsonFactory5.requiresPropertyOrdering());
assertEquals(0, jsonFactory5.getFormatGeneratorFeatures());
assertTrue(jsonFactory5.canParseAsync());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertEquals(12289, jsonFactory4.getParserFeatures());
assertEquals(543, jsonFactory4.getGeneratorFeatures());
assertSame(jsonFactory5, jsonFactory2);
assertSame(jsonFactory5, jsonFactory1);
assertSame(jsonFactory5, jsonFactory4);
assertSame(jsonFactory5, jsonFactory3);
assertSame(jsonFactory5, jsonFactory0);
assertSame(jsonFactory0, jsonFactory5);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonParser_Feature0, jsonParser_Feature2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory5);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory4, jsonFactory5);
assertSame(jsonFactory4, jsonFactory1);
assertSame(jsonFactory4, jsonFactory0);
assertSame(jsonFactory4, jsonFactory2);
assertSame(jsonFactory4, jsonFactory3);
JsonFactory jsonFactory6 = jsonFactory2.copy();
assertFalse(jsonFactory6.equals((Object)jsonFactory1));
assertFalse(jsonFactory6.equals((Object)jsonFactory3));
assertFalse(jsonFactory6.equals((Object)jsonFactory0));
assertFalse(jsonFactory6.equals((Object)jsonFactory2));
assertFalse(jsonFactory6.equals((Object)jsonFactory4));
assertFalse(jsonFactory6.equals((Object)jsonFactory5));
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature2));
assertNotNull(jsonFactory6);
assertTrue(jsonFactory6.canUseCharArrays());
assertFalse(jsonFactory6.canHandleBinaryNatively());
assertFalse(jsonFactory6.requiresPropertyOrdering());
assertEquals(0, jsonFactory6.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory6.getFormatParserFeatures());
assertEquals(" ", jsonFactory6.getRootValueSeparator());
assertEquals("JSON", jsonFactory6.getFormatName());
assertTrue(jsonFactory6.canParseAsync());
assertEquals(12289, jsonFactory6.getParserFeatures());
assertEquals(543, jsonFactory6.getGeneratorFeatures());
assertFalse(jsonFactory6.requiresCustomCodec());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertNotSame(jsonFactory6, jsonFactory1);
assertNotSame(jsonFactory6, jsonFactory3);
assertNotSame(jsonFactory6, jsonFactory0);
assertNotSame(jsonFactory6, jsonFactory2);
assertNotSame(jsonFactory6, jsonFactory4);
assertNotSame(jsonFactory6, jsonFactory5);
assertSame(jsonFactory0, jsonFactory5);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory6);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonParser_Feature0, jsonParser_Feature2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory5);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory6);
ObjectReader objectReader2 = objectReader0._new(objectReader1, jsonFactory2);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory6));
assertFalse(jsonParser_Feature0.equals((Object)jsonParser_Feature2));
assertFalse(jsonFactory2.equals((Object)jsonFactory6));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(12289, jsonFactory0.getParserFeatures());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertEquals(12289, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertSame(jsonFactory0, jsonFactory5);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory6);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonParser_Feature0, jsonParser_Feature2);
assertSame(jsonParser_Feature0, jsonParser_Feature1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory5);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory6);
try {
objectReader2.readValues(byteArray0, (-607), (-607));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test133() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[11];
byteArray0[0] = (byte)13;
byteArray0[1] = (byte) (-55);
byteArray0[2] = (byte) (-42);
byte byte0 = (byte) (-82);
byteArray0[4] = (byte) (-75);
byteArray0[5] = (byte)13;
byteArray0[6] = (byte)121;
try {
objectReader1.readTree(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type [B with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test134() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
BasicClassIntrospector basicClassIntrospector0 = new BasicClassIntrospector();
assertNotNull(basicClassIntrospector0);
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[2];
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertNotNull(jsonFactory1);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory0.setCodec(objectReader0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonGenerator_Feature0, false);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
JsonFactory jsonFactory4 = jsonFactory3.copy();
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertNotNull(jsonFactory4);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonFactory4, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory0);
ObjectReader objectReader2 = objectReader1._new(objectReader0, jsonFactory4);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory4));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory3);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonFactory4, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
byteArray0[0] = (byte)0;
byteArray0[0] = (byte) (-1);
// Undeclared exception!
try {
objectReader1.readValues(byteArray0, (int) (-1), (int) 0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test135() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
BasicClassIntrospector basicClassIntrospector0 = new BasicClassIntrospector();
assertNotNull(basicClassIntrospector0);
ObjectReader[] objectReaderArray0 = new ObjectReader[5];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(5, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
String string0 = "\":PI:Y6*POR";
PipedWriter pipedWriter0 = new PipedWriter();
assertNotNull(pipedWriter0);
int int0 = 110;
JsonNode jsonNode0 = objectReader0.createArrayNode();
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isShort());
assertTrue(jsonNode0.isEmpty());
assertTrue(jsonNode0.isArray());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isBigDecimal());
assertNotSame(objectReader0, objectReader1);
try {
objectReader1.readValue(jsonNode0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type com.fasterxml.jackson.databind.node.ArrayNode with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test136() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertNotNull(jsonFactory1);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectReader1);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
// Undeclared exception!
try {
objectReader1.readValue((InputStream) pipedInputStream0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test137() throws Throwable {
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.EAGER_DESERIALIZER_FETCH;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonParser_Feature0);
assertNotNull(jsonFactory1);
assertEquals(8225, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8225, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory2);
assertEquals(8225, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8225, jsonFactory1.getParserFeatures());
assertEquals(8225, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory2.createParser((Reader) null);
assertNotNull(readerBasedJsonParser0);
assertEquals(8225, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8225, jsonFactory1.getParserFeatures());
assertEquals(8225, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8225, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
MissingNode missingNode0 = (MissingNode)objectReader1._bindAndCloseAsTree(readerBasedJsonParser0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(missingNode0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8225, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(543, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(543, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8225, jsonFactory1.getParserFeatures());
assertEquals(8225, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(543, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8225, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(missingNode0.isBigDecimal());
assertTrue(missingNode0.isEmpty());
assertTrue(missingNode0.isMissingNode());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.isBigInteger());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isDouble());
assertFalse(missingNode0.booleanValue());
assertFalse(missingNode0.isArray());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isObject());
assertEquals("", missingNode0.asText());
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isFloat());
assertEquals(0, missingNode0.size());
assertFalse(missingNode0.isLong());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
}
@Test(timeout = 4000)
public void test138() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
Class<Map> class0 = Map.class;
MapType mapType0 = typeFactory0.constructRawMapType(class0);
assertNotNull(mapType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
MapType mapType1 = mapType0.withKeyValueHandler(typeFactory0);
assertTrue(mapType1.equals((Object)mapType0));
assertNotNull(mapType1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
assertFalse(mapType1.isJavaLangObject());
assertFalse(mapType1.hasValueHandler());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.hasHandlers());
assertFalse(mapType1.useStaticType());
assertFalse(mapType1.isFinal());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isArrayType());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isInterface());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.isContainerType());
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
MapLikeType mapLikeType0 = mapType1.withContentValueHandler(objectMapper0);
assertTrue(mapType0.equals((Object)mapType1));
assertTrue(mapType1.equals((Object)mapType0));
assertTrue(mapLikeType0.equals((Object)mapType0));
assertTrue(mapLikeType0.equals((Object)mapType1));
assertNotNull(mapLikeType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
assertFalse(mapType1.isJavaLangObject());
assertFalse(mapType1.hasValueHandler());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.hasHandlers());
assertFalse(mapType1.useStaticType());
assertFalse(mapType1.isFinal());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isArrayType());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isInterface());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.isContainerType());
assertTrue(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isFinal());
assertTrue(mapLikeType0.isInterface());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.hasValueHandler());
assertTrue(mapLikeType0.hasHandlers());
assertFalse(mapLikeType0.isArrayType());
assertEquals(2, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.useStaticType());
assertNotSame(mapType0, mapType1);
assertNotSame(mapType0, mapLikeType0);
assertNotSame(mapType1, mapType0);
assertNotSame(mapType1, mapLikeType0);
assertNotSame(mapLikeType0, mapType1);
assertNotSame(mapLikeType0, mapType0);
String string0 = mapLikeType0.getGenericSignature();
assertEquals("Ljava/util/Map<Ljava/lang/Object;Ljava/lang/Object;>;", string0);
assertTrue(mapType0.equals((Object)mapType1));
assertTrue(mapType0.equals((Object)mapLikeType0));
assertTrue(mapType1.equals((Object)mapLikeType0));
assertTrue(mapType1.equals((Object)mapType0));
assertTrue(mapLikeType0.equals((Object)mapType0));
assertTrue(mapLikeType0.equals((Object)mapType1));
assertNotNull(string0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isInterface());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.hasHandlers());
assertEquals(2, mapType0.containedTypeCount());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isAbstract());
assertFalse(mapType0.isArrayType());
assertFalse(mapType0.isConcrete());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.isEnumType());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isJavaLangObject());
assertFalse(mapType0.isFinal());
assertFalse(mapType1.isJavaLangObject());
assertFalse(mapType1.hasValueHandler());
assertEquals(2, mapType1.containedTypeCount());
assertTrue(mapType1.hasHandlers());
assertFalse(mapType1.useStaticType());
assertFalse(mapType1.isFinal());
assertTrue(mapType1.isAbstract());
assertFalse(mapType1.isArrayType());
assertFalse(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isInterface());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertTrue(mapType1.isContainerType());
assertTrue(mapLikeType0.isAbstract());
assertFalse(mapLikeType0.isCollectionLikeType());
assertFalse(mapLikeType0.isConcrete());
assertFalse(mapLikeType0.isEnumType());
assertTrue(mapLikeType0.isContainerType());
assertFalse(mapLikeType0.isFinal());
assertTrue(mapLikeType0.isInterface());
assertTrue(mapLikeType0.isMapLikeType());
assertTrue(mapLikeType0.hasContentType());
assertFalse(mapLikeType0.isPrimitive());
assertFalse(mapLikeType0.isJavaLangObject());
assertFalse(mapLikeType0.hasValueHandler());
assertTrue(mapLikeType0.hasHandlers());
assertFalse(mapLikeType0.isArrayType());
assertEquals(2, mapLikeType0.containedTypeCount());
assertFalse(mapLikeType0.useStaticType());
assertNotSame(mapType0, mapType1);
assertNotSame(mapType0, mapLikeType0);
assertNotSame(mapType1, mapType0);
assertNotSame(mapType1, mapLikeType0);
assertNotSame(mapLikeType0, mapType1);
assertNotSame(mapLikeType0, mapType0);
// Undeclared exception!
try {
objectReader0._prefetchRootDeserializer(mapLikeType0);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// com.fasterxml.jackson.databind.ObjectMapper cannot be cast to com.fasterxml.jackson.databind.JsonDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test139() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[11];
byte byte0 = (byte)13;
byteArray0[0] = (byte)13;
byte[] byteArray1 = new byte[7];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)13;
byteArray1[1] = (byte)13;
byteArray1[2] = (byte)13;
byteArray1[3] = (byte)13;
byteArray1[4] = (byte)13;
byteArray1[5] = (byte)13;
byteArray1[6] = (byte)13;
try {
objectReader1.readValue(byteArray1, (int) 13, 0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test140() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader[] objectReaderArray0 = new ObjectReader[6];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(6, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
DataInputStream dataInputStream0 = new DataInputStream(sequenceInputStream0);
assertNotNull(dataInputStream0);
try {
objectReader1.readValues((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.io.DataInputStream with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test141() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ClassIntrospector classIntrospector0 = objectMapper0.defaultClassIntrospector();
assertNotNull(classIntrospector0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Locale locale0 = Locale.KOREAN;
assertNotNull(locale0);
assertEquals("ko", locale0.toString());
assertEquals("kor", locale0.getISO3Language());
assertEquals("", locale0.getISO3Country());
assertEquals("ko", locale0.getLanguage());
assertEquals("", locale0.getVariant());
assertEquals("", locale0.getCountry());
// Undeclared exception!
try {
objectReader1.with(locale0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test142() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
try {
objectReader1.readValues((InputStream) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test143() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
try {
objectReader1._detectBindAndClose(byteArray0, (-2634), (-2628));
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test144() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Vector<IntNode> vector0 = new Vector<IntNode>();
assertNotNull(vector0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper((JsonFactory) null, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
Collection<IntNode> collection0 = objectMapper1.updateValue((Collection<IntNode>) vector0, (Object) vector0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(collection0);
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
HashMap<ArrayType, SettableBeanProperty> hashMap0 = new HashMap<ArrayType, SettableBeanProperty>();
assertNotNull(hashMap0);
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[6];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_BIG_INTEGER_FOR_INTS;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
assertEquals(6, deserializationFeatureArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(deserializationFeature0, deserializationFeature1);
ObjectReader objectReader1 = objectReader0.withAttributes(hashMap0);
assertEquals(6, deserializationFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(hashMap0.isEmpty());
assertEquals(0, hashMap0.size());
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(deserializationFeature0, deserializationFeature1);
assertNotSame(objectReader0, objectReader1);
Object object0 = new Object();
assertNotNull(object0);
ObjectReader objectReader2 = objectMapper0.readerForUpdating(object0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)0;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)0;
byteArray0[6] = (byte)0;
MappingIterator<CoreXMLDeserializers.Std> mappingIterator0 = objectReader2.readValues(byteArray0, 0, (int) 0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(7, byteArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
MissingNode missingNode0 = MissingNode.getInstance();
assertNotNull(missingNode0);
assertEquals("", missingNode0.asText());
assertEquals(0, missingNode0.size());
assertEquals(JsonNodeType.MISSING, missingNode0.getNodeType());
assertNull(missingNode0.textValue());
assertFalse(missingNode0.isBigInteger());
assertTrue(missingNode0.isMissingNode());
assertFalse(missingNode0.isInt());
assertFalse(missingNode0.isShort());
assertFalse(missingNode0.isObject());
assertFalse(missingNode0.isBigDecimal());
assertFalse(missingNode0.booleanValue());
assertNull(missingNode0.numberType());
assertFalse(missingNode0.isLong());
assertTrue(missingNode0.isEmpty());
assertFalse(missingNode0.isArray());
assertFalse(missingNode0.isFloat());
assertFalse(missingNode0.isFloatingPointNumber());
assertEquals(JsonToken.NOT_AVAILABLE, missingNode0.asToken());
assertFalse(missingNode0.isIntegralNumber());
assertFalse(missingNode0.isDouble());
}
@Test(timeout = 4000)
public void test145() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getAuthority());
assertEquals("some", uRL0.getHost());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getPort());
assertEquals("file", uRL0.getProtocol());
// Undeclared exception!
try {
objectReader0.withoutFeatures((FormatFeature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test146() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ClassIntrospector classIntrospector0 = objectMapper0.defaultClassIntrospector();
assertNotNull(classIntrospector0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("\":PI:Y6*POR");
assertNotNull(mockFile0);
try {
objectReader1.readValues((File) mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test147() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl1, (DefaultDeserializationContext) null);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[2];
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
deserializationFeatureArray0[0] = deserializationFeature1;
deserializationFeatureArray0[1] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
assertEquals(2, deserializationFeatureArray0.length);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectReader0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(deserializationFeature0, deserializationFeature1);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertEquals(2, deserializationFeatureArray0.length);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader1;
objectReaderArray0[3] = objectReader1;
ObjectReader objectReader2 = objectReader1.withFormatDetection(objectReaderArray0);
assertEquals(2, deserializationFeatureArray0.length);
assertEquals(4, objectReaderArray0.length);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(deserializationFeature0, deserializationFeature1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
ObjectReader objectReader3 = objectReader0.forType((JavaType) null);
assertEquals(2, deserializationFeatureArray0.length);
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(objectReader3);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(deserializationFeature0, deserializationFeature1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader3);
}
@Test(timeout = 4000)
public void test148() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ClassIntrospector classIntrospector0 = objectMapper0.defaultClassIntrospector();
assertNotNull(classIntrospector0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("\":PI:Y6*POR");
assertNotNull(mockFile0);
MockFile mockFile1 = new MockFile("kHVQ");
assertFalse(mockFile1.equals((Object)mockFile0));
assertNotNull(mockFile1);
// Undeclared exception!
try {
objectReader1.readValue((URL) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.net.MockURL", e);
}
}
@Test(timeout = 4000)
public void test149() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "4e0*-C+");
assertFalse(boolean0);
ArrayNode arrayNode0 = objectMapper0.createArrayNode();
assertNotNull(arrayNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isShort());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
JsonParser jsonParser0 = arrayNode0.traverse((ObjectCodec) objectMapper0);
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isShort());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertTrue(arrayNode0.isArray());
assertEquals(0, arrayNode0.size());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.hasTextCharacters());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadObjectId());
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
// Undeclared exception!
try {
objectReader0.readValue(jsonParser0, class0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test150() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
MockFile mockFile0 = new MockFile("\":PI:Y6*POR");
assertNotNull(mockFile0);
MockFile mockFile1 = new MockFile("kHVQ");
assertFalse(mockFile1.equals((Object)mockFile0));
assertNotNull(mockFile1);
try {
objectReader1.readValue((File) mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test151() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[2];
// Undeclared exception!
try {
objectReader0.withType((Type) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test152() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte) (-26);
byteArray0[2] = (byte)15;
byteArray0[3] = (byte) (-54);
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)36;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 0, (byte)0);
assertArrayEquals(new byte[] {(byte)1, (byte) (-26), (byte)15, (byte) (-54), (byte)0, (byte)36}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(0, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)1, (byte) (-26), (byte)15, (byte) (-54), (byte)0, (byte)36}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(0, byteArrayInputStream0.available());
try {
objectReader1.readTree((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.io.DataInputStream with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test153() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getPort());
assertEquals("some", uRL0.getAuthority());
assertNull(uRL0.getQuery());
assertEquals("file", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream(sequenceInputStream0);
assertNotNull(pushbackInputStream0);
DataInputStream dataInputStream0 = new DataInputStream(pushbackInputStream0);
assertNotNull(dataInputStream0);
try {
objectReader0.readTree((DataInput) dataInputStream0);
fail("Expecting exception: EOFException");
} catch(EOFException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.DataInputStream", e);
}
}
@Test(timeout = 4000)
public void test154() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
InputStream inputStream0 = null;
DataInputStream dataInputStream0 = new DataInputStream((InputStream) null);
assertNotNull(dataInputStream0);
// Undeclared exception!
try {
objectReader0.readTree((DataInput) dataInputStream0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.DataInputStream", e);
}
}
@Test(timeout = 4000)
public void test155() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Reader reader0 = null;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
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, "hN2o2C", true);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
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);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1185, (Reader) null, objectMapper0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1185, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
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);
JsonNode jsonNode0 = objectReader0._bindAsTree(readerBasedJsonParser0);
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1185, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertEquals("", jsonNode0.asText());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isLong());
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);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
URLStreamHandler uRLStreamHandler0 = mock(URLStreamHandler.class, new ViolatedAssumptionAnswer());
URL uRL0 = MockURL.URL("hN2o2C", "Cannot find a deserializer for type ", 0, "Cannot find a deserializer for type ", uRLStreamHandler0);
assertNotNull(uRL0);
assertEquals("Cannot find a deserializer for type :0", uRL0.getAuthority());
assertEquals("Cannot find a deserializer for type ", uRL0.getHost());
assertNull(uRL0.toString());
assertNull(uRL0.toExternalForm());
assertEquals("Cannot find a deserializer for type ", uRL0.getFile());
assertEquals("Cannot find a deserializer for type ", uRL0.getPath());
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertEquals(0, uRL0.getPort());
assertNull(uRL0.getRef());
assertEquals(0, uRL0.getDefaultPort());
assertEquals("hn2o2c", uRL0.getProtocol());
// Undeclared exception!
try {
objectReader0.readValue(uRL0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test156() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)13;
byteArray0[1] = (byte) (-55);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader objectReader2 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
// Undeclared exception!
try {
objectReader1.readValues((Reader) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test157() throws Throwable {
EvoSuiteURL evoSuiteURL0 = new EvoSuiteURL("http://www.someFakeButWellFormedURL.org/fooExample");
boolean boolean0 = NetworkHandling.createRemoteTextFile(evoSuiteURL0, "PAYLOAD_PROPERTY");
assertTrue(boolean0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getHttpExample();
assertNotNull(uRL0);
assertNull(uRL0.getQuery());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("http", uRL0.getProtocol());
assertEquals((-1), uRL0.getPort());
try {
objectReader0.readValue(uRL0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'PAYLOAD_PROPERTY': was expecting ('true', 'false' or 'null')
// at [Source: (URL); line: 1, column: 33]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test158() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
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());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'F';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, objectReader0, charsToNameCanonicalizer1, charArray0, 1, 13, true);
assertArrayEquals(new char[] {'F'}, charArray0);
assertEquals(1, charArray0.length);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertArrayEquals(new char[] {'F'}, charArray0);
assertEquals(1, charArray0.length);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
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());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(64, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(64, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
BeanProperty.Bogus beanProperty_Bogus0 = new BeanProperty.Bogus();
assertNotNull(beanProperty_Bogus0);
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(beanProperty_Bogus0.isRequired());
assertEquals("", beanProperty_Bogus0.getName());
SimpleType simpleType0 = (SimpleType)beanProperty_Bogus0.getType();
assertNotNull(simpleType0);
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(beanProperty_Bogus0.isRequired());
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isPrimitive());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isEnumType());
assertTrue(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1, (ResolvedType) simpleType0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test159() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNode jsonNode0 = objectReader0.readTree((InputStream) null);
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isFloat());
assertTrue(jsonNode0.isEmpty());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isDouble());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
ContextAttributes contextAttributes0 = objectReader0.getAttributes();
assertNotNull(contextAttributes0);
assertEquals(0, objectMapper0.mixInCount());
}
@Test(timeout = 4000)
public void test160() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonParser_Feature0, false);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader0 = objectMapper1.reader((FormatSchema) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(objectMapper1, objectMapper0);
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
ObjectMapper objectMapper2 = new ObjectMapper();
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectMapper2);
assertEquals(0, objectMapper2.mixInCount());
SimpleMixInResolver simpleMixInResolver0 = objectMapper2._mixIns;
assertNotNull(simpleMixInResolver0);
assertEquals(0, simpleMixInResolver0.localSize());
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = objectMapper1._configOverrides;
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig((BaseSettings) null, stdSubtypeResolver0, simpleMixInResolver0, rootNameLookup0, configOverrides0);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(deserializationConfig0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertNull(deserializationConfig0.getDefaultMergeable());
assertFalse(deserializationConfig0.requiresFullValue());
assertEquals(0, deserializationConfig0.mixInCount());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
ObjectReader objectReader1 = objectReader0._with(deserializationConfig0);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertNull(deserializationConfig0.getDefaultMergeable());
assertFalse(deserializationConfig0.requiresFullValue());
assertEquals(0, deserializationConfig0.mixInCount());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectReader1, objectReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory1.createParser("");
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(8193, 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());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
Class<MapType> class0 = MapType.class;
ArrayType arrayType0 = typeFactory0.constructArrayType(class0);
assertNotNull(arrayType0);
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.useStaticType());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.hasValueHandler());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.isCollectionLikeType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.hasContentType());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isEnumType());
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser0, (ResolvedType) arrayType0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test161() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readValues((File) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test162() throws Throwable {
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
MockFile mockFile0 = new MockFile("Not implemented for ObjectReader");
assertNotNull(mockFile0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory2);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.copy();
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl1, defaultDeserializationContext0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(objectMapper0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
Enumeration<SequenceInputStream> enumeration0 = (Enumeration<SequenceInputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
ContextAttributes contextAttributes1 = contextAttributes0.withoutSharedAttribute(sequenceInputStream0);
assertNotNull(contextAttributes1);
assertSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes0, contextAttributes1);
ContextAttributes contextAttributes2 = contextAttributes1.withPerCallAttribute((Object) null, (Object) null);
assertNotNull(contextAttributes2);
assertSame(contextAttributes1, contextAttributes2);
assertSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes2, contextAttributes1);
assertSame(contextAttributes2, contextAttributes0);
assertSame(contextAttributes0, contextAttributes2);
assertSame(contextAttributes0, contextAttributes1);
ObjectReader objectReader0 = objectMapper0.reader(contextAttributes2);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(objectReader0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
assertSame(contextAttributes0, contextAttributes2);
assertSame(contextAttributes0, contextAttributes1);
assertSame(contextAttributes1, contextAttributes2);
assertSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes2, contextAttributes1);
assertSame(contextAttributes2, contextAttributes0);
ObjectReader objectReader1 = objectReader0.withoutAttribute(jsonGenerator_Feature0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(objectReader1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(29, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(29, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(29, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
assertSame(contextAttributes0, contextAttributes2);
assertSame(contextAttributes0, contextAttributes1);
assertSame(contextAttributes1, contextAttributes2);
assertSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes2, contextAttributes1);
assertSame(contextAttributes2, contextAttributes0);
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test163() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ClassIntrospector classIntrospector0 = objectMapper0.defaultClassIntrospector();
assertNotNull(classIntrospector0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[2];
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectReader1);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonGenerator_Feature0, false);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
JsonFactory jsonFactory4 = jsonFactory3.copy();
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertNotNull(jsonFactory4);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canUseCharArrays());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory1);
ObjectReader objectReader2 = objectReader1._new(objectReader0, jsonFactory4);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory4));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory4));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canUseCharArrays());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
byteArray0[0] = (byte)0;
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory4.createParser("YzkRwp2)q@K#y~<7{ix");
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory4));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory4));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canUseCharArrays());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory1);
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
Class<List> class0 = List.class;
CollectionType collectionType0 = typeFactory0.constructCollectionType(class0, class0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(collectionType0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertFalse(collectionType0.useStaticType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isConcrete());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader3 = objectReader2.withoutAttribute(collectionType0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory4));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory4));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertFalse(jsonFactory4.equals((Object)jsonFactory3));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertEquals("JSON", jsonFactory4.getFormatName());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertTrue(jsonFactory4.canUseCharArrays());
assertFalse(collectionType0.hasHandlers());
assertTrue(collectionType0.isCollectionLikeType());
assertFalse(collectionType0.isEnumType());
assertFalse(collectionType0.hasValueHandler());
assertEquals(1, collectionType0.containedTypeCount());
assertFalse(collectionType0.useStaticType());
assertTrue(collectionType0.isAbstract());
assertFalse(collectionType0.isArrayType());
assertFalse(collectionType0.isPrimitive());
assertTrue(collectionType0.hasContentType());
assertTrue(collectionType0.isInterface());
assertFalse(collectionType0.isMapLikeType());
assertFalse(collectionType0.isJavaLangObject());
assertFalse(collectionType0.isFinal());
assertTrue(collectionType0.isContainerType());
assertFalse(collectionType0.isConcrete());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertNotSame(jsonFactory0, jsonFactory4);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(jsonFactory3, jsonFactory4);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(jsonFactory4, jsonFactory2);
assertNotSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory1);
assertNotSame(objectReader2, objectReader0);
assertSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader0);
assertSame(objectReader3, objectReader2);
}
@Test(timeout = 4000)
public void test164() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)13;
byteArray0[1] = (byte) (-55);
byteArray0[2] = (byte) (-42);
byteArray0[3] = (byte) (-82);
byteArray0[4] = (byte) (-120);
try {
objectReader1.readTree("");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.lang.String with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test165() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
IntNode intNode0 = (IntNode)objectReader0.readTree("8");
assertNotNull(intNode0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(intNode0.isInt());
assertFalse(intNode0.isBigInteger());
assertEquals(8.0, intNode0.doubleValue(), 0.01);
assertTrue(intNode0.canConvertToInt());
assertEquals(8L, intNode0.longValue());
assertFalse(intNode0.isBigDecimal());
assertEquals(0, intNode0.size());
assertFalse(intNode0.booleanValue());
assertFalse(intNode0.isArray());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertTrue(intNode0.canConvertToLong());
assertTrue(intNode0.isEmpty());
assertNull(intNode0.textValue());
assertEquals(8.0F, intNode0.floatValue(), 0.01F);
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertFalse(intNode0.isNaN());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertFalse(intNode0.isShort());
assertEquals(8, intNode0.intValue());
assertFalse(intNode0.isMissingNode());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isObject());
assertFalse(intNode0.isLong());
assertEquals((short)8, intNode0.shortValue());
assertFalse(intNode0.isFloat());
assertFalse(intNode0.isDouble());
assertFalse(intNode0.isFloatingPointNumber());
// Undeclared exception!
try {
objectReader0.withoutFeatures((DeserializationFeature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test166() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(1, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)13;
byte byte0 = (byte) (-55);
byteArray0[1] = (byte)13;
HashMap<ArrayType, SettableBeanProperty> hashMap0 = new HashMap<ArrayType, SettableBeanProperty>();
assertNotNull(hashMap0);
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
// Undeclared exception!
try {
objectReader1.withAttributes(hashMap0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test167() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
Class<AbstractDeserializer> class0 = AbstractDeserializer.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
boolean boolean2 = objectReader0.isEnabled(jsonParser_Feature0);
assertTrue(boolean2);
assertFalse(boolean2 == boolean1);
assertFalse(boolean2 == boolean0);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test168() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getHttpExample();
assertNotNull(uRL0);
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("http", uRL0.getProtocol());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(uRL0.getRef());
assertNull(uRL0.getQuery());
try {
objectReader0._inputStream(uRL0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Could not find: www.someFakeButWellFormedURL.org
//
verifyException("org.evosuite.runtime.mock.java.net.EvoHttpURLConnection", e);
}
}
@Test(timeout = 4000)
public void test169() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
Vector<IntNode> vector0 = new Vector<IntNode>();
assertNotNull(vector0);
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
Collection<IntNode> collection0 = objectMapper0.updateValue((Collection<IntNode>) vector0, (Object) vector0);
assertNotNull(collection0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
assertEquals(10, vector0.capacity());
HashMap<ArrayType, SettableBeanProperty> hashMap0 = new HashMap<ArrayType, SettableBeanProperty>();
assertNotNull(hashMap0);
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
ObjectReader objectReader1 = objectReader0.withAttributes(hashMap0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, hashMap0.size());
assertTrue(hashMap0.isEmpty());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
// Undeclared exception!
try {
objectReader0.readValues(byteArray0, 756, 756);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 756
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test170() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[0];
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(binaryNode0);
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isLong());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isMissingNode());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.isFloatingPointNumber());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isIntegralNumber());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isShort());
assertFalse(binaryNode0.isBigDecimal());
assertFalse(binaryNode0.isInt());
JsonParser jsonParser0 = objectMapper0.treeAsTokens(binaryNode0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isLong());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isMissingNode());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.isFloatingPointNumber());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isIntegralNumber());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isShort());
assertFalse(binaryNode0.isBigDecimal());
assertFalse(binaryNode0.isInt());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
JsonParserDelegate jsonParserDelegate0 = new JsonParserDelegate(jsonParser0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(jsonParserDelegate0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isLong());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isMissingNode());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.isFloatingPointNumber());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isIntegralNumber());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.booleanValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isShort());
assertFalse(binaryNode0.isBigDecimal());
assertFalse(binaryNode0.isInt());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParserDelegate0.getFormatFeatures());
assertEquals(0, jsonParserDelegate0.getFeatureMask());
assertFalse(jsonParserDelegate0.canReadObjectId());
assertFalse(jsonParserDelegate0.requiresCustomCodec());
assertFalse(jsonParserDelegate0.canParseAsync());
assertFalse(jsonParserDelegate0.canReadTypeId());
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) jsonParserDelegate0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test171() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
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, jsonNodeFactory0, true);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
PipedWriter pipedWriter0 = new PipedWriter();
assertNotNull(pipedWriter0);
PipedReader pipedReader1 = new PipedReader(pipedWriter0);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(pipedReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = ']';
charArray0[1] = '-';
charArray0[2] = 'W';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 873, pipedReader1, objectMapper0, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(873, readerBasedJsonParser0.getFeatureMask());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideStdFeatures(0, 3);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(872, readerBasedJsonParser0.getFeatureMask());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(872, readerBasedJsonParser1.getFeatureMask());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(pipedReader1, pipedReader0);
ReaderBasedJsonParser readerBasedJsonParser2 = (ReaderBasedJsonParser)objectReader0._considerFilter(readerBasedJsonParser1, false);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser2);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(872, readerBasedJsonParser0.getFeatureMask());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(872, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(872, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(readerBasedJsonParser1, readerBasedJsonParser2);
assertSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(pipedReader1, pipedReader0);
TypeReference<CoreXMLDeserializers.Std> typeReference0 = (TypeReference<CoreXMLDeserializers.Std>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn(simpleType0).when(typeReference0).getType();
Iterator<CoreXMLDeserializers.Std> iterator0 = objectReader0.readValues((JsonParser) readerBasedJsonParser2, typeReference0);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(872, readerBasedJsonParser0.getFeatureMask());
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());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(872, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(872, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
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);
assertNotSame(pipedReader1, pipedReader0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(readerBasedJsonParser1, readerBasedJsonParser2);
assertSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertSame(readerBasedJsonParser2, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test172() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-55);
byteArray0[2] = (byte) (-42);
Class<String> class0 = String.class;
ObjectReader objectReader2 = objectReader0.withType(class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
PipedReader pipedReader0 = new PipedReader(1586);
assertNotNull(pipedReader0);
try {
objectReader1.readTree((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.io.PipedReader with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test173() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl1, defaultDeserializationContext_Impl0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
Class<BigIntegerNode> class0 = BigIntegerNode.class;
ObjectReader objectReader0 = objectMapper1.readerFor(class0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
// Undeclared exception!
try {
objectReader0.forType((TypeReference<?>) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test174() throws Throwable {
MockFile mockFile0 = new MockFile("wjk__S9m?zk$cT");
assertNotNull(mockFile0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[8];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
deserializationFeatureArray0[2] = deserializationFeature1;
deserializationFeatureArray0[3] = deserializationFeature0;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
deserializationFeatureArray0[7] = deserializationFeature0;
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature2 = DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY;
DeserializationFeature[] deserializationFeatureArray1 = new DeserializationFeature[5];
assertFalse(deserializationFeatureArray1.equals((Object)deserializationFeatureArray0));
deserializationFeatureArray1[0] = deserializationFeature1;
deserializationFeatureArray1[1] = deserializationFeature0;
deserializationFeatureArray1[2] = deserializationFeature1;
deserializationFeatureArray1[3] = deserializationFeature0;
deserializationFeatureArray1[4] = deserializationFeature1;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature2, deserializationFeatureArray1);
assertEquals(5, deserializationFeatureArray1.length);
assertFalse(deserializationFeature2.equals((Object)deserializationFeature1));
assertFalse(deserializationFeature2.equals((Object)deserializationFeature0));
assertFalse(deserializationFeatureArray1.equals((Object)deserializationFeatureArray0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(deserializationFeature2, deserializationFeature1);
assertNotSame(deserializationFeature2, deserializationFeature0);
assertNotSame(deserializationFeatureArray1, deserializationFeatureArray0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
MapperFeature mapperFeature0 = MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS;
boolean boolean0 = objectReader0.isEnabled(mapperFeature0);
assertTrue(boolean0);
assertEquals(5, deserializationFeatureArray1.length);
assertFalse(deserializationFeature2.equals((Object)deserializationFeature1));
assertFalse(deserializationFeature2.equals((Object)deserializationFeature0));
assertFalse(deserializationFeatureArray1.equals((Object)deserializationFeatureArray0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(deserializationFeature2, deserializationFeature1);
assertNotSame(deserializationFeature2, deserializationFeature0);
assertNotSame(deserializationFeatureArray1, deserializationFeatureArray0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
}
@Test(timeout = 4000)
public void test175() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonGenerator jsonGenerator0 = null;
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
// Undeclared exception!
try {
objectReader0.withFeatures((JsonParser.Feature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test176() throws Throwable {
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
PlaceholderForType placeholderForType0 = new PlaceholderForType(1970);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isEnumType());
assertTrue(placeholderForType0.isJavaLangObject());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
Class<ArrayType> class0 = ArrayType.class;
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, dataInputStream0, true);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(iOContext0);
assertEquals(1, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
UTF8StreamJsonParser uTF8StreamJsonParser0 = new UTF8StreamJsonParser(iOContext0, 2, dataInputStream0, objectMapper0, (ByteQuadsCanonicalizer) null, byteArray0, 1, 1953, false);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertEquals(2, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
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);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(uTF8StreamJsonParser0, (TokenFilter) null, false, false);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(filteringParserDelegate0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertEquals(2, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.canParseAsync());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals(0, filteringParserDelegate0.currentTokenId());
assertNull(filteringParserDelegate0.currentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(2, filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
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);
FormatSchema formatSchema0 = filteringParserDelegate0.getSchema();
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNull(formatSchema0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertEquals(2, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.canParseAsync());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals(0, filteringParserDelegate0.currentTokenId());
assertNull(filteringParserDelegate0.currentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(2, filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
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);
ObjectReader objectReader0 = objectMapper0.reader((FormatSchema) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0._bindAndReadValues((JsonParser) uTF8StreamJsonParser0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test177() throws Throwable {
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null);
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
// Undeclared exception!
try {
objectReader0.with(deserializationFeature1, (DeserializationFeature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test178() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byte byte0 = (byte) (-55);
byteArray0[1] = (byte) (-55);
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals("some", uRL0.getAuthority());
assertEquals("file", uRL0.getProtocol());
assertEquals("some", uRL0.getHost());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
// Undeclared exception!
try {
objectReader1.readValues(uRL0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test179() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
// Undeclared exception!
try {
objectReader0.readValue(uRL0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test180() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[5];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.UNWRAP_ROOT_VALUE;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
assertEquals(5, deserializationFeatureArray0.length);
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(deserializationFeature0, deserializationFeature1);
DeserializationConfig deserializationConfig0 = objectReader0.getConfig();
assertEquals(5, deserializationFeatureArray0.length);
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertNotNull(deserializationConfig0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig0.requiresFullValue());
assertEquals(0, deserializationConfig0.mixInCount());
assertTrue(deserializationConfig0.useRootWrapping());
assertEquals(237282448, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertNotSame(deserializationFeature0, deserializationFeature1);
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, (Object) null, true);
assertNotNull(iOContext0);
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(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);
PipedReader pipedReader0 = new PipedReader(1);
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
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);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
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());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, pipedReader0, objectReader0, charsToNameCanonicalizer1);
assertEquals(5, deserializationFeatureArray0.length);
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.skipChildren();
assertEquals(5, deserializationFeatureArray0.length);
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(deserializationFeature0, deserializationFeature1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test181() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
URL uRL0 = MockURL.getHttpExample();
assertNotNull(uRL0);
assertEquals("http", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals((-1), uRL0.getPort());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(uRL0.getQuery());
try {
objectReader0.readValue(uRL0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Could not find: www.someFakeButWellFormedURL.org
//
verifyException("org.evosuite.runtime.mock.java.net.EvoHttpURLConnection", e);
}
}
@Test(timeout = 4000)
public void test182() throws Throwable {
byte[] byteArray0 = new byte[4];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(4, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(4, byteArrayInputStream0.available());
int int0 = byteArrayInputStream0.read(byteArray0);
assertEquals(4, int0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(4, byteArray0.length);
assertEquals(0, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(4, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(0, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1);
assertNotNull(objectMapper0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectIdGenerators.IntSequenceGenerator objectIdGenerators_IntSequenceGenerator0 = new ObjectIdGenerators.IntSequenceGenerator();
assertNotNull(objectIdGenerators_IntSequenceGenerator0);
assertFalse(objectIdGenerators_IntSequenceGenerator0.maySerializeAsObject());
ObjectReader objectReader0 = objectMapper0.readerForUpdating(objectIdGenerators_IntSequenceGenerator0);
assertNotNull(objectReader0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectIdGenerators_IntSequenceGenerator0.maySerializeAsObject());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ConcurrentHashMap.KeySetView<IntNode, Boolean> concurrentHashMap_KeySetView0 = ConcurrentHashMap.newKeySet();
assertNotNull(concurrentHashMap_KeySetView0);
Class<Boolean> class0 = Boolean.TYPE;
assertNotNull(class0);
assertFalse(class0.isInterface());
assertEquals("boolean", class0.toString());
assertTrue(class0.isPrimitive());
assertFalse(class0.isArray());
assertEquals(1041, class0.getModifiers());
assertFalse(class0.isEnum());
assertFalse(class0.isSynthetic());
assertFalse(class0.isAnnotation());
JavaType javaType0 = objectMapper0.constructType(class0);
assertNotNull(javaType0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(class0.isInterface());
assertEquals("boolean", class0.toString());
assertTrue(class0.isPrimitive());
assertFalse(class0.isArray());
assertEquals(1041, class0.getModifiers());
assertFalse(class0.isEnum());
assertFalse(class0.isSynthetic());
assertFalse(class0.isAnnotation());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isContainerType());
assertTrue(javaType0.isAbstract());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isJavaLangObject());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isPrimitive());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isEnumType());
assertTrue(javaType0.isFinal());
assertFalse(javaType0.hasHandlers());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ReferenceType referenceType0 = ReferenceType.upgradeFrom(javaType0, javaType0);
assertNotNull(referenceType0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(class0.isInterface());
assertEquals("boolean", class0.toString());
assertTrue(class0.isPrimitive());
assertFalse(class0.isArray());
assertEquals(1041, class0.getModifiers());
assertFalse(class0.isEnum());
assertFalse(class0.isSynthetic());
assertFalse(class0.isAnnotation());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isContainerType());
assertTrue(javaType0.isAbstract());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isJavaLangObject());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isPrimitive());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isEnumType());
assertTrue(javaType0.isFinal());
assertFalse(javaType0.hasHandlers());
assertTrue(referenceType0.isPrimitive());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.isAbstract());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ReferenceType referenceType1 = referenceType0.withContentValueHandler(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(4, byteArray0.length);
assertTrue(referenceType1.equals((Object)referenceType0));
assertNotNull(referenceType1);
assertEquals(0, byteArrayInputStream0.available());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(class0.isInterface());
assertEquals("boolean", class0.toString());
assertTrue(class0.isPrimitive());
assertFalse(class0.isArray());
assertEquals(1041, class0.getModifiers());
assertFalse(class0.isEnum());
assertFalse(class0.isSynthetic());
assertFalse(class0.isAnnotation());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isContainerType());
assertTrue(javaType0.isAbstract());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isJavaLangObject());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isPrimitive());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isEnumType());
assertTrue(javaType0.isFinal());
assertFalse(javaType0.hasHandlers());
assertTrue(referenceType0.isPrimitive());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.useStaticType());
assertFalse(referenceType0.hasValueHandler());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isJavaLangObject());
assertTrue(referenceType0.isConcrete());
assertFalse(referenceType0.isCollectionLikeType());
assertTrue(referenceType0.isAbstract());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.hasHandlers());
assertFalse(referenceType0.isEnumType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isEnumType());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.isCollectionLikeType());
assertTrue(referenceType1.isPrimitive());
assertTrue(referenceType1.isReferenceType());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.hasHandlers());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isInterface());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isAbstract());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.hasValueHandler());
assertFalse(referenceType1.isArrayType());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType1, referenceType0);
// Undeclared exception!
try {
objectMapper0.updateValue((Collection<IntNode>) concurrentHashMap_KeySetView0, (Object) referenceType1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test183() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-55);
byteArray0[2] = (byte) (-42);
byteArray0[3] = (byte) (-81);
try {
objectReader1.readValue("GqdEN>wq8e=&\">");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type java.lang.String with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test184() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-55);
byteArray0[2] = (byte) (-42);
byteArray0[3] = (byte) (-82);
byteArray0[4] = (byte) (-120);
byteArray0[5] = (byte) (-120);
byteArray0[6] = (byte)121;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, (byte) (-82), (-9));
assertArrayEquals(new byte[] {(byte)0, (byte) (-55), (byte) (-42), (byte) (-82), (byte) (-120), (byte) (-120), (byte)121}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals((-9), byteArrayInputStream0.available());
try {
objectReader1._detectBindAndCloseAsTree(byteArrayInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats []
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test185() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader(929);
assertNotNull(pipedReader0);
JsonNode jsonNode0 = objectReader0.readTree((Reader) null);
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.booleanValue());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isEmpty());
assertNull(jsonNode0.textValue());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isBigInteger());
}
@Test(timeout = 4000)
public void test186() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader(929);
assertNotNull(pipedReader0);
try {
objectReader0.readTree((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test187() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
File file0 = MockFile.createTempFile("F#%.PJ=K: }kFZb|S1", "F#%.PJ=K: }kFZb|S1");
assertNotNull(file0);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.getName());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
String string0 = file0.getAbsolutePath();
assertEquals("/tmp/F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", string0);
assertNotNull(string0);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.getName());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
MockFile mockFile0 = new MockFile(file0, "F#%.PJ=K: }kFZb|S1");
assertFalse(mockFile0.equals((Object)file0));
assertNotNull(mockFile0);
// Undeclared exception!
try {
objectReader0.readValues(file0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test188() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte)2;
byteArray0[2] = (byte) (-53);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-1), (byte)2, (byte) (-53)}, byteArray0);
assertEquals(3, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(3, byteArrayInputStream0.available());
try {
objectReader0.readValues((InputStream) byteArrayInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: (ByteArrayInputStream); line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test189() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
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(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, objectMapper0, true);
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
PipedReader pipedReader0 = new PipedReader(3);
assertNotNull(pipedReader0);
Class<BinaryNode> class0 = BinaryNode.class;
ObjectReader objectReader1 = objectMapper0.readerWithView(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, pipedReader0, objectReader1, charsToNameCanonicalizer0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
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());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideFormatFeatures(2, (-353));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
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());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(objectReader1, objectReader0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
Class<BooleanNode> class1 = BooleanNode.class;
PlaceholderForType placeholderForType0 = new PlaceholderForType(1);
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
TypeBindings typeBindings0 = TypeBindings.emptyBindings();
assertNotNull(typeBindings0);
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
ArrayType arrayType0 = ArrayType.construct((JavaType) placeholderForType0, typeBindings0);
assertNotNull(arrayType0);
assertTrue(arrayType0.isArrayType());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.isEnumType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isFinal());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertTrue(arrayType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
TypeBindings typeBindings1 = arrayType0.getBindings();
assertNotNull(typeBindings1);
assertTrue(arrayType0.isArrayType());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.isEnumType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isFinal());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertTrue(arrayType0.isConcrete());
assertTrue(typeBindings1.isEmpty());
assertEquals(0, typeBindings1.size());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(typeBindings1, typeBindings0);
assertSame(typeBindings0, typeBindings1);
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class1, typeBindings1);
assertNotNull(resolvedRecursiveType0);
assertTrue(arrayType0.isArrayType());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.isEnumType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isFinal());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertTrue(arrayType0.isConcrete());
assertTrue(typeBindings1.isEmpty());
assertEquals(0, typeBindings1.size());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.isEnumType());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
ResolvedRecursiveType resolvedRecursiveType1 = (ResolvedRecursiveType)resolvedRecursiveType0.withContentTypeHandler(typeBindings0);
assertNotNull(resolvedRecursiveType1);
assertTrue(arrayType0.isArrayType());
assertEquals(0, arrayType0.containedTypeCount());
assertFalse(arrayType0.isEnumType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isFinal());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertTrue(arrayType0.isConcrete());
assertTrue(typeBindings1.isEmpty());
assertEquals(0, typeBindings1.size());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.isEnumType());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType1.isCollectionLikeType());
assertEquals(0, resolvedRecursiveType1.containedTypeCount());
assertFalse(resolvedRecursiveType1.isContainerType());
assertFalse(resolvedRecursiveType1.isAbstract());
assertFalse(resolvedRecursiveType1.isJavaLangObject());
assertTrue(resolvedRecursiveType1.isConcrete());
assertFalse(resolvedRecursiveType1.hasHandlers());
assertFalse(resolvedRecursiveType1.isArrayType());
assertTrue(resolvedRecursiveType1.hasContentType());
assertFalse(resolvedRecursiveType1.useStaticType());
assertFalse(resolvedRecursiveType1.isFinal());
assertFalse(resolvedRecursiveType1.hasValueHandler());
assertFalse(resolvedRecursiveType1.isEnumType());
assertFalse(resolvedRecursiveType1.isPrimitive());
assertFalse(resolvedRecursiveType1.isMapLikeType());
assertFalse(resolvedRecursiveType1.isInterface());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isEnumType());
assertEquals(0, placeholderForType0.containedTypeCount());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isContainerType());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(typeBindings1, typeBindings0);
assertSame(resolvedRecursiveType0, resolvedRecursiveType1);
assertSame(resolvedRecursiveType1, resolvedRecursiveType0);
assertSame(typeBindings0, typeBindings1);
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1, (ResolvedType) resolvedRecursiveType1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test190() throws Throwable {
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
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);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertNotNull(fileDescriptor0);
assertFalse(fileDescriptor0.valid());
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor0);
assertNotNull(mockFileOutputStream0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte)1;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, objectMapper0, mockFileOutputStream0, byteArray0, 3, true);
assertArrayEquals(new byte[] {(byte)0, (byte)1}, byteArray0);
assertEquals(2, byteArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(uTF8JsonGenerator0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(fileDescriptor0.valid());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
FormatSchema formatSchema0 = uTF8JsonGenerator0.getSchema();
assertArrayEquals(new byte[] {(byte)0, (byte)1}, byteArray0);
assertEquals(2, byteArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNull(formatSchema0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(fileDescriptor0.valid());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotSame(objectMapper0, objectMapper1);
ObjectReader objectReader0 = objectMapper1.reader((FormatSchema) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
TokenFilterContext tokenFilterContext0 = TokenFilterContext.createRootContext(tokenFilter0);
assertNotNull(tokenFilterContext0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(tokenFilterContext0.inArray());
assertTrue(tokenFilterContext0.isStartHandled());
assertFalse(tokenFilterContext0.hasCurrentIndex());
assertEquals(0, tokenFilterContext0.getCurrentIndex());
assertNull(tokenFilterContext0.getCurrentName());
assertEquals(0, tokenFilterContext0.getEntryCount());
assertEquals("ROOT", tokenFilterContext0.getTypeDesc());
assertEquals("root", tokenFilterContext0.typeDesc());
assertFalse(tokenFilterContext0.inObject());
assertFalse(tokenFilterContext0.hasCurrentName());
assertTrue(tokenFilterContext0.inRoot());
JsonPointer jsonPointer0 = tokenFilterContext0.pathAsPointer();
assertNotNull(jsonPointer0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(tokenFilterContext0.inArray());
assertTrue(tokenFilterContext0.isStartHandled());
assertFalse(tokenFilterContext0.hasCurrentIndex());
assertEquals(0, tokenFilterContext0.getCurrentIndex());
assertNull(tokenFilterContext0.getCurrentName());
assertEquals(0, tokenFilterContext0.getEntryCount());
assertEquals("ROOT", tokenFilterContext0.getTypeDesc());
assertEquals("root", tokenFilterContext0.typeDesc());
assertFalse(tokenFilterContext0.inObject());
assertFalse(tokenFilterContext0.hasCurrentName());
assertTrue(tokenFilterContext0.inRoot());
assertEquals("", jsonPointer0.toString());
assertTrue(jsonPointer0.mayMatchProperty());
assertFalse(jsonPointer0.mayMatchElement());
assertEquals((-1), jsonPointer0.getMatchingIndex());
assertTrue(jsonPointer0.matches());
assertEquals("", jsonPointer0.getMatchingProperty());
assertEquals('/', JsonPointer.SEPARATOR);
ObjectReader objectReader1 = objectReader0.at(jsonPointer0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(tokenFilterContext0.inArray());
assertTrue(tokenFilterContext0.isStartHandled());
assertFalse(tokenFilterContext0.hasCurrentIndex());
assertEquals(0, tokenFilterContext0.getCurrentIndex());
assertNull(tokenFilterContext0.getCurrentName());
assertEquals(0, tokenFilterContext0.getEntryCount());
assertEquals("ROOT", tokenFilterContext0.getTypeDesc());
assertEquals("root", tokenFilterContext0.typeDesc());
assertFalse(tokenFilterContext0.inObject());
assertFalse(tokenFilterContext0.hasCurrentName());
assertTrue(tokenFilterContext0.inRoot());
assertEquals("", jsonPointer0.toString());
assertTrue(jsonPointer0.mayMatchProperty());
assertFalse(jsonPointer0.mayMatchElement());
assertEquals((-1), jsonPointer0.getMatchingIndex());
assertTrue(jsonPointer0.matches());
assertEquals("", jsonPointer0.getMatchingProperty());
assertEquals('/', JsonPointer.SEPARATOR);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test191() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
String string0 = "=JYKQ";
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("=JYKQ/=JYKQ");
boolean boolean0 = FileSystemHandling.appendLineToFile(evoSuiteFile0, "=JYKQ");
assertTrue(boolean0);
MockFile mockFile0 = new MockFile("=JYKQ", "=JYKQ");
assertNotNull(mockFile0);
try {
objectReader0.readValue((File) mockFile0);
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: (org.evosuite.runtime.mock.java.io.MockFile); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test192() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
ObjectReader objectReader1 = objectReader0.withValueToUpdate(tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)111;
byteArray0[3] = (byte) (-71);
byteArray0[4] = (byte)4;
byteArray0[5] = (byte) (-21);
byteArray0[6] = (byte)1;
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)1, (byte)111, (byte) (-71), (byte)4, (byte) (-21), (byte)1}, byteArray0);
assertEquals(7, byteArray0.length);
assertNotNull(readerBasedJsonParser0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) readerBasedJsonParser0, (JavaType) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test193() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
MockFile mockFile0 = new MockFile("Y\"Rg<", "=JYKQ");
assertNotNull(mockFile0);
ArrayDeque<ObjectReader> arrayDeque0 = new ArrayDeque<ObjectReader>();
assertNotNull(arrayDeque0);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(arrayDeque0);
assertNotNull(dataFormatReaders0);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
PlaceholderForType placeholderForType0 = new PlaceholderForType(4382);
assertNotNull(placeholderForType0);
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(placeholderForType0);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.with((DeserializationConfig) null);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
DataFormatReaders dataFormatReaders3 = dataFormatReaders2.withMaxInputLookahead(998);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders3);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
ObjectReader[] objectReaderArray0 = new ObjectReader[9];
ObjectReader objectReader1 = objectMapper0.readerFor((JavaType) placeholderForType0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
assertNotSame(objectReader1, objectReader0);
objectReaderArray0[0] = objectReader1;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[6] = objectReader0;
Class<Integer> class0 = Integer.class;
ObjectReader objectReader2 = objectMapper0.readerFor(class0);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
objectReaderArray0[7] = objectReader2;
objectReaderArray0[8] = objectReader0;
DataFormatReaders dataFormatReaders4 = dataFormatReaders3.with(objectReaderArray0);
assertEquals(9, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders4.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders4.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders4.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders4.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders4);
assertFalse(arrayDeque0.contains(objectReader0));
assertTrue(arrayDeque0.isEmpty());
assertEquals(0, arrayDeque0.size());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isPrimitive());
assertTrue(placeholderForType0.isJavaLangObject());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasValueHandler());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isContainerType());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders4);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders4, dataFormatReaders1);
assertNotSame(dataFormatReaders4, dataFormatReaders3);
assertNotSame(dataFormatReaders4, dataFormatReaders2);
assertNotSame(dataFormatReaders4, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders4);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders4);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders4);
try {
objectReader0._reportUnkownFormat(dataFormatReaders4, (DataFormatReaders.Match) null);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot detect format from input, does not look like any of detectable formats [JSON, JSON, JSON, JSON, JSON, JSON, JSON, JSON, JSON]
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test194() throws Throwable {
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
Object object0 = new Object();
assertNotNull(object0);
ObjectReader objectReader0 = objectMapper1.readerForUpdating(object0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
MappingIterator<Integer> mappingIterator0 = objectReader1.readValues((Reader) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(mappingIterator0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test195() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ConcurrentHashMap<String, BooleanNode> concurrentHashMap0 = new ConcurrentHashMap<String, BooleanNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectReader objectReader1 = objectReader0.withAttributes(concurrentHashMap0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0.readValue((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test196() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
JsonParser jsonParser0 = objectReader0._considerFilter((JsonParser) null, true);
assertNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null, (-1), (-1));
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test197() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ValueNode valueNode0 = jsonNodeFactory0.pojoNode(objectReader0);
assertNotNull(valueNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(valueNode0.isMissingNode());
assertFalse(valueNode0.isLong());
assertFalse(valueNode0.isDouble());
assertFalse(valueNode0.isFloatingPointNumber());
assertEquals(0, valueNode0.size());
assertNull(valueNode0.numberType());
assertFalse(valueNode0.isObject());
assertFalse(valueNode0.booleanValue());
assertFalse(valueNode0.isShort());
assertFalse(valueNode0.isInt());
assertFalse(valueNode0.isBigDecimal());
assertTrue(valueNode0.isEmpty());
assertFalse(valueNode0.isBigInteger());
assertNull(valueNode0.textValue());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, valueNode0.asToken());
assertFalse(valueNode0.isIntegralNumber());
assertFalse(valueNode0.isFloat());
assertEquals(JsonNodeType.POJO, valueNode0.getNodeType());
assertFalse(valueNode0.isArray());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.at((String) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test198() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
File file0 = MockFile.createTempFile("F#%.PJ=K: }kFZb|S1", "F#%.PJ=K: }kFZb|S1");
assertNotNull(file0);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.getName());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/F#%.PJ=K: }kFZb|S10F#%.PJ=K: }kFZb|S1", file0.toString());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
MockFile mockFile0 = new MockFile(file0, "JsonSerializer of type ");
assertFalse(mockFile0.equals((Object)file0));
assertNotNull(mockFile0);
try {
objectReader0.readValues((File) mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test199() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<AbstractDeserializer> class0 = AbstractDeserializer.class;
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader0 = objectMapper1.readerWithView(class0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
ObjectReader objectReader1 = objectReader0.with((FormatSchema) null);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
MapperFeature mapperFeature0 = MapperFeature.SORT_PROPERTIES_ALPHABETICALLY;
boolean boolean0 = objectReader0.isEnabled(mapperFeature0);
assertFalse(boolean0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test200() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URI uRI0 = null;
MapperFeature mapperFeature0 = MapperFeature.USE_BASE_TYPE_AS_DEFAULT_IMPL;
boolean boolean0 = objectReader0.isEnabled(mapperFeature0);
assertFalse(boolean0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
MockURI.resolve((URI) null, "");
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.net.MockURI", e);
}
}
@Test(timeout = 4000)
public void test201() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
int int0 = (-1);
JsonGenerator.Feature[] jsonGenerator_FeatureArray0 = new JsonGenerator.Feature[6];
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
jsonGenerator_FeatureArray0[0] = jsonGenerator_Feature0;
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.QUOTE_FIELD_NAMES;
jsonGenerator_FeatureArray0[1] = jsonGenerator_Feature1;
JsonGenerator.Feature jsonGenerator_Feature2 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
jsonGenerator_FeatureArray0[2] = jsonGenerator_Feature2;
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_SINGLE_QUOTES;
ObjectMapper objectMapper1 = objectMapper0.configure(jsonParser_Feature0, true);
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
JsonGenerator.Feature jsonGenerator_Feature3 = JsonGenerator.Feature.IGNORE_UNKNOWN;
jsonGenerator_FeatureArray0[3] = jsonGenerator_Feature3;
// Undeclared exception!
try {
objectReader0.with((JsonFactory) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test202() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(pipedInputStream0);
assertNotNull(dataInputStream0);
assertEquals(0, pipedInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
try {
objectReader0.readValues((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedInputStream", e);
}
}
@Test(timeout = 4000)
public void test203() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
BaseSettings baseSettings0 = ObjectMapper.DEFAULT_BASE;
assertNotNull(baseSettings0);
assertFalse(baseSettings0.hasExplicitTimeZone());
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
ConfigOverrides configOverrides0 = new ConfigOverrides();
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig(baseSettings0, stdSubtypeResolver0, (SimpleMixInResolver) null, (RootNameLookup) null, configOverrides0);
assertNotNull(deserializationConfig0);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
DeserializationConfig deserializationConfig1 = new DeserializationConfig(deserializationConfig0, (SimpleMixInResolver) null);
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertNotNull(deserializationConfig1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig1.getRootName());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ContextAttributes contextAttributes1 = contextAttributes0.withoutSharedAttribute(deserializationConfig1);
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertNotNull(contextAttributes1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig1.getRootName());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertNotSame(deserializationConfig0, deserializationConfig1);
assertNotSame(deserializationConfig1, deserializationConfig0);
assertSame(contextAttributes0, contextAttributes1);
assertSame(contextAttributes1, contextAttributes0);
DeserializationConfig deserializationConfig2 = new DeserializationConfig(deserializationConfig1, contextAttributes1);
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig0));
assertNotNull(deserializationConfig2);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig1.getRootName());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertTrue(deserializationConfig2.canOverrideAccessModifiers());
assertNull(deserializationConfig2.getRootName());
assertFalse(deserializationConfig2.useRootWrapping());
assertTrue(deserializationConfig2.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig2.shouldSortPropertiesAlphabetically());
assertFalse(deserializationConfig2.requiresFullValue());
assertNull(deserializationConfig2.getDefaultMergeable());
assertEquals(237020304, deserializationConfig2.getDeserializationFeatures());
ObjectReader objectReader1 = objectReader0.with(deserializationConfig2);
assertFalse(deserializationConfig0.equals((Object)deserializationConfig2));
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig2));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig2.equals((Object)deserializationConfig0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getRootName());
assertFalse(deserializationConfig0.requiresFullValue());
assertNull(deserializationConfig1.getRootName());
assertNull(deserializationConfig1.getDefaultMergeable());
assertFalse(deserializationConfig1.requiresFullValue());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertFalse(deserializationConfig1.useRootWrapping());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertTrue(deserializationConfig2.canOverrideAccessModifiers());
assertNull(deserializationConfig2.getRootName());
assertFalse(deserializationConfig2.useRootWrapping());
assertTrue(deserializationConfig2.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig2.shouldSortPropertiesAlphabetically());
assertFalse(deserializationConfig2.requiresFullValue());
assertNull(deserializationConfig2.getDefaultMergeable());
assertEquals(237020304, deserializationConfig2.getDeserializationFeatures());
assertNotSame(objectReader0, objectReader1);
assertNotSame(deserializationConfig0, deserializationConfig2);
assertNotSame(deserializationConfig0, deserializationConfig1);
assertNotSame(deserializationConfig1, deserializationConfig0);
assertNotSame(deserializationConfig1, deserializationConfig2);
assertSame(contextAttributes0, contextAttributes1);
assertSame(contextAttributes1, contextAttributes0);
assertNotSame(deserializationConfig2, deserializationConfig1);
assertNotSame(deserializationConfig2, deserializationConfig0);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null, (-1), (-1));
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test204() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
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, objectReader1, false);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, pipedReader0, objectReader0, charsToNameCanonicalizer0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
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);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8192, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(8192, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
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);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
try {
objectReader0._bindAndCloseAsTree(readerBasedJsonParser1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test205() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
int int0 = 116;
// Undeclared exception!
try {
objectReader0.readTree((byte[]) null, 116, 116);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test206() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isFinal());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
PipedWriter pipedWriter0 = new PipedWriter();
assertNotNull(pipedWriter0);
PipedReader pipedReader0 = new PipedReader(pipedWriter0, 64);
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
SimpleAbstractTypeResolver simpleAbstractTypeResolver0 = new SimpleAbstractTypeResolver();
assertNotNull(simpleAbstractTypeResolver0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAbstractTypeResolver(simpleAbstractTypeResolver0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
JsonParser jsonParser0 = defaultDeserializationContext_Impl0.getParser();
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNull(jsonParser0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
Iterator<ArrayType> iterator0 = objectReader0.readValues((JsonParser) null, (ResolvedType) simpleType0);
assertNotNull(iterator0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isFinal());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
}
@Test(timeout = 4000)
public void test207() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonpCharacterEscapes jsonpCharacterEscapes0 = JsonpCharacterEscapes.instance();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonFactory jsonFactory3 = jsonFactory2.copy();
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
StringWriter stringWriter0 = new StringWriter();
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
StringWriter stringWriter1 = stringWriter0.append('8');
assertNotNull(stringWriter1);
assertEquals("8", stringWriter0.toString());
assertEquals("8", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
WriterBasedJsonGenerator writerBasedJsonGenerator0 = (WriterBasedJsonGenerator)jsonFactory3.createGenerator((Writer) stringWriter1);
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertNotNull(writerBasedJsonGenerator0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals("8", stringWriter0.toString());
assertEquals("8", stringWriter1.toString());
assertEquals(0, writerBasedJsonGenerator0.getOutputBuffered());
assertEquals(0, writerBasedJsonGenerator0.getFormatFeatures());
assertTrue(writerBasedJsonGenerator0.canOmitFields());
assertFalse(writerBasedJsonGenerator0.isClosed());
assertFalse(writerBasedJsonGenerator0.canWriteTypeId());
assertFalse(writerBasedJsonGenerator0.canWriteObjectId());
assertTrue(writerBasedJsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, writerBasedJsonGenerator0.getHighestEscapedChar());
assertEquals(31, writerBasedJsonGenerator0.getFeatureMask());
assertFalse(writerBasedJsonGenerator0.canWriteBinaryNatively());
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory3);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
// Undeclared exception!
try {
objectReader0.writeValue(writerBasedJsonGenerator0, stringWriter1);
fail("Expecting exception: UnsupportedOperationException");
} catch(UnsupportedOperationException e) {
//
// Not implemented for ObjectReader
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test208() throws Throwable {
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1);
assertNotNull(objectMapper0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std0);
assertNotNull(objectReader0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
Stack<JsonNode> stack0 = new Stack<JsonNode>();
assertNotNull(stack0);
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0, stack0);
assertNotNull(arrayNode0);
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertTrue(arrayNode0.isArray());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isFloat());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
JsonParser jsonParser0 = arrayNode0.traverse((ObjectCodec) objectReader0);
assertNotNull(jsonParser0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertTrue(arrayNode0.isArray());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isFloat());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadTypeId());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadObjectId());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonNode jsonNode0 = objectReader0._bindAndCloseAsTree(jsonParser0);
assertTrue(jsonNode0.equals((Object)arrayNode0));
assertNotNull(jsonNode0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, stack0.size());
assertEquals(10, stack0.capacity());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertTrue(stack0.empty());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isMissingNode());
assertTrue(arrayNode0.isArray());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isFloat());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigInteger());
assertFalse(arrayNode0.isShort());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.canReadTypeId());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertTrue(jsonParser0.isClosed());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadObjectId());
assertTrue(jsonNode0.isArray());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isShort());
assertEquals(0, jsonNode0.size());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isMissingNode());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isBigDecimal());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isLong());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(arrayNode0, jsonNode0);
assertNotSame(jsonNode0, arrayNode0);
}
@Test(timeout = 4000)
public void test209() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser((char[]) null, 19, (-133));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.currentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = (DefaultDeserializationContext.Impl)objectReader0._context;
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
PlaceholderForType placeholderForType0 = new PlaceholderForType((-133));
assertNotNull(placeholderForType0);
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
ObjectReader objectReader1 = objectReader0.forType((JavaType) placeholderForType0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(placeholderForType0.isInterface());
assertFalse(placeholderForType0.isArrayType());
assertFalse(placeholderForType0.hasHandlers());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.useStaticType());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isAbstract());
assertTrue(placeholderForType0.isConcrete());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1._initForReading(defaultDeserializationContext_Impl0, (JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test210() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectMapper0.reader();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
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, objectReader0, true);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(iOContext0);
assertEquals(0, objectMapper0.mixInCount());
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.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("KMldU[KY5");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectMapper0, charsToNameCanonicalizer0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
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());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
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);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
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());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isNaN());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.currentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
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);
assertNotSame(objectReader0, objectReader1);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'KMldU': 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 test211() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getHttpExample();
assertNotNull(uRL0);
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals((-1), uRL0.getPort());
assertEquals("http", uRL0.getProtocol());
assertEquals("http://www.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("www.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getUserInfo());
assertNull(uRL0.getQuery());
assertNull(uRL0.getRef());
assertEquals((-1), uRL0.getDefaultPort());
try {
objectReader0.readValues(uRL0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Could not find: www.someFakeButWellFormedURL.org
//
verifyException("org.evosuite.runtime.mock.java.net.EvoHttpURLConnection", e);
}
}
@Test(timeout = 4000)
public void test212() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
System.setCurrentTimeMillis(0L);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder(jsonFactory0);
assertNotNull(jsonFactoryBuilder0);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
JsonFactory jsonFactory1 = new JsonFactory(jsonFactoryBuilder0);
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Integer> class0 = Integer.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DefaultDeserializationContext defaultDeserializationContext0 = objectReader0.createDeserializationContext((JsonParser) null);
assertNotNull(defaultDeserializationContext0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, defaultDeserializationContext0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper1.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader1 = objectMapper1.reader(jsonNodeFactory0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
ObjectReader[] objectReaderArray0 = new ObjectReader[9];
objectReaderArray0[0] = objectReader0;
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES;
ObjectReader objectReader2 = objectMapper1.reader(deserializationFeature0);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader2);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectMapper1, objectMapper0);
objectReaderArray0[1] = objectReader2;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader1;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[7] = objectReader1;
objectReaderArray0[8] = objectReader0;
ObjectReader objectReader3 = objectReader1.withFormatDetection(objectReaderArray0);
assertEquals(9, objectReaderArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(defaultDeserializationContext0.canOverrideAccessModifiers());
assertEquals(237020304, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader3);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
}
@Test(timeout = 4000)
public void test213() throws Throwable {
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-91);
byteArray0[1] = (byte)62;
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "7.d{3GP{");
assertFalse(boolean0);
byteArray0[2] = (byte)1;
byteArray0[3] = (byte) (-106);
boolean boolean1 = NetworkHandling.createRemoteTextFile((EvoSuiteURL) null, "Root name '%s' does not match expected ('%s') for type %s");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
byteArray0[4] = (byte)1;
byteArray0[5] = (byte) (-112);
byteArray0[6] = (byte)3;
byteArray0[7] = (byte)1;
boolean boolean2 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean2);
assertArrayEquals(new byte[] {(byte) (-91), (byte)62, (byte)1, (byte) (-106), (byte)1, (byte) (-112), (byte)3, (byte)1}, byteArray0);
assertEquals(8, byteArray0.length);
assertTrue(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.with((FormatFeature) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test214() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<DoubleNode> class0 = DoubleNode.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isFinal());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)56;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)1;
byteArray0[2] = (byte)0;
byteArray0[4] = (byte)37;
byteArray0[5] = (byte)111;
byteArray0[6] = (byte) (-115);
byteArray0[7] = (byte) (-1);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)56, (byte)0, (byte)0, (byte)0, (byte)37, (byte)111, (byte) (-115), (byte) (-1)}, byteArray0);
assertEquals(8, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(8, byteArrayInputStream0.available());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
try {
objectReader0.readValues((InputStream) byteArrayInputStream0);
fail("Expecting exception: CharConversionException");
} catch(CharConversionException e) {
//
// Invalid UTF-32 character 0xff8c6f25 (above 0x0010ffff) at char #1, byte #7)
//
verifyException("com.fasterxml.jackson.core.io.UTF32Reader", e);
}
}
@Test(timeout = 4000)
public void test215() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
PipedInputStream pipedInputStream0 = new PipedInputStream(200);
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
try {
objectReader0.readValue((InputStream) pipedInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedInputStream", e);
}
}
@Test(timeout = 4000)
public void test216() throws Throwable {
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8449, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8449, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setCharacterEscapes((CharacterEscapes) null);
assertNotNull(jsonFactory2);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8449, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8449, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8449, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
assertNotNull(objectMapper0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8449, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8449, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8449, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
ShortNode shortNode0 = new ShortNode((short)45);
assertNotNull(shortNode0);
assertTrue(shortNode0.canConvertToLong());
assertFalse(shortNode0.isMissingNode());
assertFalse(shortNode0.booleanValue());
assertTrue(shortNode0.isShort());
assertTrue(shortNode0.canConvertToInt());
assertEquals(0, shortNode0.size());
assertFalse(shortNode0.isLong());
assertFalse(shortNode0.isArray());
assertFalse(shortNode0.isDouble());
assertEquals(JsonNodeType.NUMBER, shortNode0.getNodeType());
assertNull(shortNode0.textValue());
assertFalse(shortNode0.isBigDecimal());
assertEquals(JsonParser.NumberType.INT, shortNode0.numberType());
assertEquals(45L, shortNode0.longValue());
assertEquals(45.0, shortNode0.doubleValue(), 0.01);
assertFalse(shortNode0.isObject());
assertFalse(shortNode0.isFloat());
assertFalse(shortNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, shortNode0.asToken());
assertEquals(45, shortNode0.intValue());
assertFalse(shortNode0.isBigInteger());
assertTrue(shortNode0.isIntegralNumber());
assertTrue(shortNode0.isEmpty());
assertEquals((short)45, shortNode0.shortValue());
assertFalse(shortNode0.isNaN());
assertEquals(45.0F, shortNode0.floatValue(), 0.01F);
assertFalse(shortNode0.isInt());
ObjectReader objectReader0 = objectMapper0.readerForUpdating(shortNode0);
assertNotNull(objectReader0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8449, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8449, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8449, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(shortNode0.canConvertToLong());
assertFalse(shortNode0.isMissingNode());
assertFalse(shortNode0.booleanValue());
assertTrue(shortNode0.isShort());
assertTrue(shortNode0.canConvertToInt());
assertEquals(0, shortNode0.size());
assertFalse(shortNode0.isLong());
assertFalse(shortNode0.isArray());
assertFalse(shortNode0.isDouble());
assertEquals(JsonNodeType.NUMBER, shortNode0.getNodeType());
assertNull(shortNode0.textValue());
assertFalse(shortNode0.isBigDecimal());
assertEquals(JsonParser.NumberType.INT, shortNode0.numberType());
assertEquals(45L, shortNode0.longValue());
assertEquals(45.0, shortNode0.doubleValue(), 0.01);
assertFalse(shortNode0.isObject());
assertFalse(shortNode0.isFloat());
assertFalse(shortNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, shortNode0.asToken());
assertEquals(45, shortNode0.intValue());
assertFalse(shortNode0.isBigInteger());
assertTrue(shortNode0.isIntegralNumber());
assertTrue(shortNode0.isEmpty());
assertEquals((short)45, shortNode0.shortValue());
assertFalse(shortNode0.isNaN());
assertEquals(45.0F, shortNode0.floatValue(), 0.01F);
assertFalse(shortNode0.isInt());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
MappingIterator<InputStream> mappingIterator0 = objectReader0.readValues("");
assertNotNull(mappingIterator0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8449, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8449, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8449, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(shortNode0.canConvertToLong());
assertFalse(shortNode0.isMissingNode());
assertFalse(shortNode0.booleanValue());
assertTrue(shortNode0.isShort());
assertTrue(shortNode0.canConvertToInt());
assertEquals(0, shortNode0.size());
assertFalse(shortNode0.isLong());
assertFalse(shortNode0.isArray());
assertFalse(shortNode0.isDouble());
assertEquals(JsonNodeType.NUMBER, shortNode0.getNodeType());
assertNull(shortNode0.textValue());
assertFalse(shortNode0.isBigDecimal());
assertEquals(JsonParser.NumberType.INT, shortNode0.numberType());
assertEquals(45L, shortNode0.longValue());
assertEquals(45.0, shortNode0.doubleValue(), 0.01);
assertFalse(shortNode0.isObject());
assertFalse(shortNode0.isFloat());
assertFalse(shortNode0.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_INT, shortNode0.asToken());
assertEquals(45, shortNode0.intValue());
assertFalse(shortNode0.isBigInteger());
assertTrue(shortNode0.isIntegralNumber());
assertTrue(shortNode0.isEmpty());
assertEquals((short)45, shortNode0.shortValue());
assertFalse(shortNode0.isNaN());
assertEquals(45.0F, shortNode0.floatValue(), 0.01F);
assertFalse(shortNode0.isInt());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test217() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<DoubleNode> class0 = DoubleNode.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
Class<IntNode> class1 = IntNode.class;
SimpleType simpleType1 = SimpleType.constructUnsafe(class1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isAbstract());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isFinal());
assertNotSame(simpleType1, simpleType0);
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) simpleType1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isAbstract());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isFinal());
assertNotSame(simpleType1, simpleType0);
ObjectReader objectReader1 = objectMapper0.readerWithView(class1);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertNotNull(bigDecimal0);
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
DecimalNode decimalNode0 = new DecimalNode(bigDecimal0);
assertNotNull(decimalNode0);
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertTrue(decimalNode0.isEmpty());
assertFalse(decimalNode0.isBigInteger());
assertNull(decimalNode0.textValue());
assertFalse(decimalNode0.isObject());
assertFalse(decimalNode0.booleanValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode0.asToken());
assertFalse(decimalNode0.isInt());
assertFalse(decimalNode0.isShort());
assertTrue(decimalNode0.isBigDecimal());
assertFalse(decimalNode0.isMissingNode());
assertFalse(decimalNode0.isDouble());
assertFalse(decimalNode0.isLong());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode0.numberType());
assertFalse(decimalNode0.isNaN());
assertEquals(0, decimalNode0.size());
assertFalse(decimalNode0.isIntegralNumber());
assertEquals(JsonNodeType.NUMBER, decimalNode0.getNodeType());
assertFalse(decimalNode0.isFloat());
assertFalse(decimalNode0.isArray());
assertTrue(decimalNode0.isFloatingPointNumber());
JsonParser jsonParser0 = objectReader0.treeAsTokens(decimalNode0);
assertFalse(simpleType1.equals((Object)simpleType0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isAbstract());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isFinal());
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertTrue(decimalNode0.isEmpty());
assertFalse(decimalNode0.isBigInteger());
assertNull(decimalNode0.textValue());
assertFalse(decimalNode0.isObject());
assertFalse(decimalNode0.booleanValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode0.asToken());
assertFalse(decimalNode0.isInt());
assertFalse(decimalNode0.isShort());
assertTrue(decimalNode0.isBigDecimal());
assertFalse(decimalNode0.isMissingNode());
assertFalse(decimalNode0.isDouble());
assertFalse(decimalNode0.isLong());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode0.numberType());
assertFalse(decimalNode0.isNaN());
assertEquals(0, decimalNode0.size());
assertFalse(decimalNode0.isIntegralNumber());
assertEquals(JsonNodeType.NUMBER, decimalNode0.getNodeType());
assertFalse(decimalNode0.isFloat());
assertFalse(decimalNode0.isArray());
assertTrue(decimalNode0.isFloatingPointNumber());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canReadTypeId());
assertNotSame(simpleType1, simpleType0);
assertNotSame(objectReader0, objectReader1);
DecimalNode decimalNode1 = (DecimalNode)objectReader0._bindAndCloseAsTree(jsonParser0);
assertFalse(simpleType1.equals((Object)simpleType0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(decimalNode1.equals((Object)decimalNode0));
assertNotNull(decimalNode1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isAbstract());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isCollectionLikeType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isFinal());
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertTrue(decimalNode0.isEmpty());
assertFalse(decimalNode0.isBigInteger());
assertNull(decimalNode0.textValue());
assertFalse(decimalNode0.isObject());
assertFalse(decimalNode0.booleanValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode0.asToken());
assertFalse(decimalNode0.isInt());
assertFalse(decimalNode0.isShort());
assertTrue(decimalNode0.isBigDecimal());
assertFalse(decimalNode0.isMissingNode());
assertFalse(decimalNode0.isDouble());
assertFalse(decimalNode0.isLong());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode0.numberType());
assertFalse(decimalNode0.isNaN());
assertEquals(0, decimalNode0.size());
assertFalse(decimalNode0.isIntegralNumber());
assertEquals(JsonNodeType.NUMBER, decimalNode0.getNodeType());
assertFalse(decimalNode0.isFloat());
assertFalse(decimalNode0.isArray());
assertTrue(decimalNode0.isFloatingPointNumber());
assertTrue(jsonParser0.isClosed());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(decimalNode1.booleanValue());
assertFalse(decimalNode1.isArray());
assertTrue(decimalNode1.isFloatingPointNumber());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode1.asToken());
assertEquals(JsonNodeType.NUMBER, decimalNode1.getNodeType());
assertFalse(decimalNode1.isInt());
assertFalse(decimalNode1.isObject());
assertFalse(decimalNode1.isLong());
assertTrue(decimalNode1.isEmpty());
assertEquals(0, decimalNode1.size());
assertFalse(decimalNode1.isIntegralNumber());
assertFalse(decimalNode1.isDouble());
assertFalse(decimalNode1.isFloat());
assertNull(decimalNode1.textValue());
assertFalse(decimalNode1.isNaN());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode1.numberType());
assertFalse(decimalNode1.isMissingNode());
assertTrue(decimalNode1.isBigDecimal());
assertFalse(decimalNode1.isBigInteger());
assertFalse(decimalNode1.isShort());
assertNotSame(simpleType1, simpleType0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(decimalNode0, decimalNode1);
assertNotSame(decimalNode1, decimalNode0);
// Undeclared exception!
try {
objectReader1._detectBindAndClose(byteArray0, 2388, (byte)0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test218() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte) (-40);
byteArray0[1] = (byte)1;
byteArray0[2] = (byte) (-63);
byteArray0[3] = (byte) (-26);
byteArray0[4] = (byte)97;
byteArray0[5] = (byte) (-79);
byteArray0[6] = (byte)46;
byteArray0[7] = (byte)9;
byteArray0[8] = (byte) (-92);
// Undeclared exception!
try {
objectReader0.readValues(byteArray0, (-1326), 1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -1326
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test219() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFileExample();
assertNotNull(uRL0);
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getRef());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getQuery());
assertEquals("some", uRL0.getAuthority());
assertEquals("some", uRL0.getHost());
assertEquals("file", uRL0.getProtocol());
// Undeclared exception!
try {
objectReader0.readValues(uRL0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test220() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
assertNotNull(jsonFactoryBuilder0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
assertNotNull(jsonFactory0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
Class<SimpleType> class0 = SimpleType.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(15, jsonFactoryBuilder0.factoryFeaturesMask());
assertEquals(0, jsonFactoryBuilder0.highestNonEscapedChar());
assertEquals(31, jsonFactoryBuilder0.streamWriteFeatures());
assertEquals(8193, jsonFactoryBuilder0.streamReadFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ConcurrentHashMap<String, JsonNode> concurrentHashMap0 = new ConcurrentHashMap<String, JsonNode>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectNode objectNode0 = new ObjectNode(jsonNodeFactory0, concurrentHashMap0);
assertNotNull(objectNode0);
assertTrue(concurrentHashMap0.isEmpty());
assertEquals("", objectNode0.asText());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isShort());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isMissingNode());
ObjectNode objectNode1 = objectNode0.removeAll();
assertNotNull(objectNode1);
assertTrue(concurrentHashMap0.isEmpty());
assertEquals("", objectNode0.asText());
assertEquals(0, objectNode0.size());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isShort());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertEquals(0, objectNode1.size());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isIntegralNumber());
assertTrue(objectNode1.isEmpty());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isBigDecimal());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
Short short0 = new Short((short)2416);
assertEquals((short)2416, (short)short0);
assertNotNull(short0);
ObjectNode objectNode2 = objectNode1.put("JSON", short0);
assertNotNull(objectNode2);
assertFalse(concurrentHashMap0.isEmpty());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isShort());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isBigDecimal());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.booleanValue());
assertNull(objectNode2.numberType());
assertEquals(1, objectNode2.size());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode2);
assertSame(objectNode1, objectNode0);
assertSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode1);
int int0 = 0;
ObjectNode objectNode3 = objectNode2.put("", 0);
assertNotNull(objectNode3);
assertFalse(concurrentHashMap0.isEmpty());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertEquals(2, objectNode0.size());
assertFalse(objectNode0.isShort());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertEquals(2, objectNode1.size());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isBigDecimal());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.booleanValue());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertEquals(2, objectNode2.size());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals(2, objectNode3.size());
assertFalse(objectNode3.isBigInteger());
assertFalse(objectNode3.isMissingNode());
assertNull(objectNode3.textValue());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isInt());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isBigDecimal());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.isLong());
assertEquals("", objectNode3.asText());
assertFalse(objectNode3.isArray());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isFloatingPointNumber());
assertSame(objectNode0, objectNode3);
assertSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode3);
assertSame(objectNode1, objectNode2);
assertSame(objectNode1, objectNode0);
assertSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode3);
assertSame(objectNode2, objectNode1);
assertSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode2);
JsonNode jsonNode0 = objectNode3.remove("yqn{Gw'");
assertNull(jsonNode0);
assertFalse(concurrentHashMap0.isEmpty());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isLong());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigInteger());
assertEquals(2, objectNode0.size());
assertFalse(objectNode0.isShort());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertEquals(2, objectNode1.size());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isMissingNode());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.booleanValue());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isArray());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isBigDecimal());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isLong());
assertFalse(objectNode2.isShort());
assertFalse(objectNode2.isInt());
assertTrue(objectNode2.isObject());
assertFalse(objectNode2.isArray());
assertFalse(objectNode2.isEmpty());
assertFalse(objectNode2.isMissingNode());
assertFalse(objectNode2.isLong());
assertFalse(objectNode2.isIntegralNumber());
assertFalse(objectNode2.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode2.getNodeType());
assertFalse(objectNode2.isBigDecimal());
assertFalse(objectNode2.booleanValue());
assertNull(objectNode2.numberType());
assertFalse(objectNode2.isBigInteger());
assertNull(objectNode2.textValue());
assertEquals("", objectNode2.asText());
assertEquals(JsonToken.START_OBJECT, objectNode2.asToken());
assertEquals(2, objectNode2.size());
assertFalse(objectNode2.isFloat());
assertFalse(objectNode2.isFloatingPointNumber());
assertEquals(2, objectNode3.size());
assertFalse(objectNode3.isBigInteger());
assertFalse(objectNode3.isMissingNode());
assertNull(objectNode3.textValue());
assertTrue(objectNode3.isObject());
assertFalse(objectNode3.isShort());
assertFalse(objectNode3.isInt());
assertFalse(objectNode3.isEmpty());
assertFalse(objectNode3.isBigDecimal());
assertNull(objectNode3.numberType());
assertFalse(objectNode3.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode3.asToken());
assertFalse(objectNode3.isLong());
assertEquals("", objectNode3.asText());
assertFalse(objectNode3.isArray());
assertFalse(objectNode3.isFloat());
assertFalse(objectNode3.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode3.getNodeType());
assertFalse(objectNode3.isIntegralNumber());
assertFalse(objectNode3.isFloatingPointNumber());
assertSame(objectNode0, objectNode3);
assertSame(objectNode0, objectNode1);
assertSame(objectNode0, objectNode2);
assertSame(objectNode1, objectNode3);
assertSame(objectNode1, objectNode2);
assertSame(objectNode1, objectNode0);
assertSame(objectNode2, objectNode0);
assertSame(objectNode2, objectNode3);
assertSame(objectNode2, objectNode1);
assertSame(objectNode3, objectNode1);
assertSame(objectNode3, objectNode0);
assertSame(objectNode3, objectNode2);
// Undeclared exception!
try {
objectReader1.readValue((JsonNode) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.node.TreeTraversingParser", e);
}
}
@Test(timeout = 4000)
public void test221() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectMapper2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
ObjectReader objectReader0 = objectMapper2.reader();
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
ConfigOverrides configOverrides0 = new ConfigOverrides();
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
JsonInclude.Value jsonInclude_Value0 = configOverrides0.getDefaultInclusion();
assertNotNull(jsonInclude_Value0);
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(JsonInclude.Include.USE_DEFAULTS, jsonInclude_Value0.getContentInclusion());
assertEquals(JsonInclude.Include.USE_DEFAULTS, jsonInclude_Value0.getValueInclusion());
ObjectMapper objectMapper3 = objectMapper0.setDefaultPropertyInclusion(jsonInclude_Value0);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper3.equals((Object)objectMapper1));
assertFalse(objectMapper3.equals((Object)objectMapper2));
assertNotNull(objectMapper3);
assertEquals(0, objectMapper0.mixInCount());
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(JsonInclude.Include.USE_DEFAULTS, jsonInclude_Value0.getContentInclusion());
assertEquals(JsonInclude.Include.USE_DEFAULTS, jsonInclude_Value0.getValueInclusion());
assertEquals(0, objectMapper3.mixInCount());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertSame(objectMapper0, objectMapper3);
assertNotSame(objectMapper3, objectMapper1);
assertSame(objectMapper3, objectMapper0);
assertNotSame(objectMapper3, objectMapper2);
int int0 = 1535;
PipedReader pipedReader0 = new PipedReader(1535);
assertNotNull(pipedReader0);
boolean boolean0 = pipedReader0.markSupported();
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory0.createParser((Reader) pipedReader0);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
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(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertSame(objectMapper0, objectMapper3);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)objectReader0._considerFilter(readerBasedJsonParser0, true);
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper3));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper3));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper2.mixInCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.currentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(8193, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper0, objectMapper1);
assertSame(objectMapper0, objectMapper3);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper3);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectMapper2, objectMapper3);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
try {
objectReader0._bindAndReadValues((JsonParser) readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test222() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl1, (DefaultDeserializationContext) null);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
ConcurrentHashMap<String, Object> concurrentHashMap0 = new ConcurrentHashMap<String, Object>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ConfigOverrides configOverrides0 = new ConfigOverrides();
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
JsonSetter.Value jsonSetter_Value0 = configOverrides0.getDefaultSetterInfo();
assertNotNull(jsonSetter_Value0);
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(Nulls.DEFAULT, jsonSetter_Value0.getValueNulls());
assertNull(jsonSetter_Value0.nonDefaultValueNulls());
assertEquals(Nulls.DEFAULT, jsonSetter_Value0.getContentNulls());
assertNull(jsonSetter_Value0.nonDefaultContentNulls());
ObjectMapper objectMapper1 = objectMapper0.setDefaultSetterInfo(jsonSetter_Value0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectMapper1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertNull(configOverrides0.getDefaultMergeable());
assertEquals(Nulls.DEFAULT, jsonSetter_Value0.getValueNulls());
assertNull(jsonSetter_Value0.nonDefaultValueNulls());
assertEquals(Nulls.DEFAULT, jsonSetter_Value0.getContentNulls());
assertNull(jsonSetter_Value0.nonDefaultContentNulls());
assertEquals(0, objectMapper1.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(concurrentHashMap0);
assertNotNull(injectableValues_Std0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std0);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertSame(objectMapper0, objectMapper1);
ObjectReader[] objectReaderArray0 = new ObjectReader[5];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(5, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)91;
byteArray0[1] = (byte) (-59);
byteArray0[2] = (byte)86;
byteArray0[3] = (byte)61;
byteArray0[4] = (byte) (-3);
byteArray0[5] = (byte)0;
byteArray0[6] = (byte) (-128);
byteArray0[7] = (byte)0;
byteArray0[8] = (byte)63;
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders0.findFormat(byteArray0);
assertArrayEquals(new byte[] {(byte)91, (byte) (-59), (byte)86, (byte)61, (byte) (-3), (byte)0, (byte) (-128), (byte)0, (byte)63}, byteArray0);
assertEquals(9, byteArray0.length);
assertEquals(5, objectReaderArray0.length);
assertNotNull(dataFormatReaders_Match0);
assertEquals(MatchStrength.SOLID_MATCH, dataFormatReaders_Match0.getMatchStrength());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)dataFormatReaders_Match0.createParserWithMatch();
assertArrayEquals(new byte[] {(byte)91, (byte) (-59), (byte)86, (byte)61, (byte) (-3), (byte)0, (byte) (-128), (byte)0, (byte)63}, byteArray0);
assertEquals(9, byteArray0.length);
assertEquals(5, objectReaderArray0.length);
assertNotNull(uTF8StreamJsonParser0);
assertEquals(MatchStrength.SOLID_MATCH, dataFormatReaders_Match0.getMatchStrength());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertNull(uTF8StreamJsonParser0.currentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
UTF8StreamJsonParser uTF8StreamJsonParser1 = (UTF8StreamJsonParser)objectReader0._considerFilter(uTF8StreamJsonParser0, true);
assertArrayEquals(new byte[] {(byte)91, (byte) (-59), (byte)86, (byte)61, (byte) (-3), (byte)0, (byte) (-128), (byte)0, (byte)63}, byteArray0);
assertEquals(9, byteArray0.length);
assertEquals(5, objectReaderArray0.length);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(uTF8StreamJsonParser1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertEquals(MatchStrength.SOLID_MATCH, dataFormatReaders_Match0.getMatchStrength());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertNull(uTF8StreamJsonParser0.currentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser1.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser1.getFormatFeatures());
assertFalse(uTF8StreamJsonParser1.requiresCustomCodec());
assertNull(uTF8StreamJsonParser1.getLastClearedToken());
assertEquals(8193, uTF8StreamJsonParser1.getFeatureMask());
assertFalse(uTF8StreamJsonParser1.canReadTypeId());
assertEquals(1, uTF8StreamJsonParser1.getTokenLineNr());
assertFalse(uTF8StreamJsonParser1.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser1.currentToken());
assertFalse(uTF8StreamJsonParser1.hasCurrentToken());
assertFalse(uTF8StreamJsonParser1.isClosed());
assertNull(uTF8StreamJsonParser1.getCurrentName());
assertEquals(0, uTF8StreamJsonParser1.getCurrentTokenId());
assertNull(uTF8StreamJsonParser1.getCurrentToken());
assertFalse(uTF8StreamJsonParser1.hasTextCharacters());
assertFalse(uTF8StreamJsonParser1.canParseAsync());
assertFalse(uTF8StreamJsonParser1.isNaN());
assertEquals(0L, uTF8StreamJsonParser1.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser1.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser1.getTokenColumnNr());
assertEquals(0, uTF8StreamJsonParser1.currentTokenId());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertSame(objectMapper0, objectMapper1);
assertSame(uTF8StreamJsonParser0, uTF8StreamJsonParser1);
assertSame(uTF8StreamJsonParser1, uTF8StreamJsonParser0);
JsonToken jsonToken0 = objectReader0._initForReading((DeserializationContext) null, uTF8StreamJsonParser1);
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertArrayEquals(new byte[] {(byte)91, (byte) (-59), (byte)86, (byte)61, (byte) (-3), (byte)0, (byte) (-128), (byte)0, (byte)63}, byteArray0);
assertEquals(9, byteArray0.length);
assertEquals(5, objectReaderArray0.length);
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isScalarValue());
assertTrue(jsonToken0.isStructStart());
assertEquals(3, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertEquals("[", jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertEquals(MatchStrength.SOLID_MATCH, dataFormatReaders_Match0.getMatchStrength());
assertTrue(dataFormatReaders_Match0.hasMatch());
assertEquals("JSON", dataFormatReaders_Match0.getMatchedFormatName());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertEquals(3, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(JsonToken.START_ARRAY, uTF8StreamJsonParser0.getCurrentToken());
assertEquals(JsonToken.START_ARRAY, uTF8StreamJsonParser0.currentToken());
assertEquals(2, uTF8StreamJsonParser0.getTokenColumnNr());
assertEquals(3, uTF8StreamJsonParser0.currentTokenId());
assertTrue(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertTrue(uTF8StreamJsonParser0.hasCurrentToken());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser1.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser1.getFormatFeatures());
assertFalse(uTF8StreamJsonParser1.requiresCustomCodec());
assertNull(uTF8StreamJsonParser1.getLastClearedToken());
assertEquals(8193, uTF8StreamJsonParser1.getFeatureMask());
assertTrue(uTF8StreamJsonParser1.hasCurrentToken());
assertFalse(uTF8StreamJsonParser1.canReadTypeId());
assertEquals(1, uTF8StreamJsonParser1.getTokenLineNr());
assertEquals(JsonToken.START_ARRAY, uTF8StreamJsonParser1.currentToken());
assertEquals(JsonToken.START_ARRAY, uTF8StreamJsonParser1.getCurrentToken());
assertFalse(uTF8StreamJsonParser1.isClosed());
assertNull(uTF8StreamJsonParser1.getCurrentName());
assertEquals(3, uTF8StreamJsonParser1.currentTokenId());
assertEquals(3, uTF8StreamJsonParser1.getCurrentTokenId());
assertTrue(uTF8StreamJsonParser1.isExpectedStartArrayToken());
assertEquals(1L, uTF8StreamJsonParser1.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser1.hasTextCharacters());
assertFalse(uTF8StreamJsonParser1.canParseAsync());
assertFalse(uTF8StreamJsonParser1.isNaN());
assertFalse(uTF8StreamJsonParser1.isExpectedStartObjectToken());
assertEquals(2, uTF8StreamJsonParser1.getTokenColumnNr());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertSame(objectMapper0, objectMapper1);
assertSame(uTF8StreamJsonParser0, uTF8StreamJsonParser1);
assertSame(uTF8StreamJsonParser1, uTF8StreamJsonParser0);
}
@Test(timeout = 4000)
public void test223() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
ClassLoader classLoader0 = ClassLoader.getSystemClassLoader();
assertNotNull(classLoader0);
TypeFactory typeFactory1 = typeFactory0.withClassLoader(classLoader0);
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(typeFactory1);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
Class<MissingNode> class0 = MissingNode.class;
ArrayType arrayType0 = typeFactory1.constructArrayType(class0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(arrayType0);
assertTrue(arrayType0.hasContentType());
assertTrue(arrayType0.isFinal());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.isPrimitive());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.useStaticType());
assertFalse(arrayType0.isAbstract());
assertTrue(arrayType0.isConcrete());
assertFalse(arrayType0.isJavaLangObject());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
// Undeclared exception!
try {
objectReader0.readValues((byte[]) null, (-3799), 917);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test224() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Vector<ObjectReader> vector0 = new Vector<ObjectReader>();
assertNotNull(vector0);
assertFalse(vector0.contains(objectReader0));
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(vector0);
assertNotNull(dataFormatReaders0);
assertFalse(vector0.contains(objectReader0));
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
DecimalNode decimalNode0 = DecimalNode.ZERO;
assertNotNull(decimalNode0);
assertTrue(decimalNode0.isEmpty());
assertFalse(decimalNode0.booleanValue());
assertNull(decimalNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode0.asToken());
assertFalse(decimalNode0.isObject());
assertFalse(decimalNode0.isBigInteger());
assertTrue(decimalNode0.isBigDecimal());
assertFalse(decimalNode0.isShort());
assertFalse(decimalNode0.isInt());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode0.numberType());
assertEquals(0, decimalNode0.size());
assertFalse(decimalNode0.isMissingNode());
assertFalse(decimalNode0.isLong());
assertFalse(decimalNode0.isNaN());
assertFalse(decimalNode0.isFloat());
assertFalse(decimalNode0.isArray());
assertEquals(JsonNodeType.NUMBER, decimalNode0.getNodeType());
assertFalse(decimalNode0.isIntegralNumber());
assertTrue(decimalNode0.isFloatingPointNumber());
assertFalse(decimalNode0.isDouble());
ObjectReader objectReader1 = objectReader0.withAttribute(decimalNode0, objectMapper0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(decimalNode0.isEmpty());
assertFalse(decimalNode0.booleanValue());
assertNull(decimalNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, decimalNode0.asToken());
assertFalse(decimalNode0.isObject());
assertFalse(decimalNode0.isBigInteger());
assertTrue(decimalNode0.isBigDecimal());
assertFalse(decimalNode0.isShort());
assertFalse(decimalNode0.isInt());
assertEquals(JsonParser.NumberType.BIG_DECIMAL, decimalNode0.numberType());
assertEquals(0, decimalNode0.size());
assertFalse(decimalNode0.isMissingNode());
assertFalse(decimalNode0.isLong());
assertFalse(decimalNode0.isNaN());
assertFalse(decimalNode0.isFloat());
assertFalse(decimalNode0.isArray());
assertEquals(JsonNodeType.NUMBER, decimalNode0.getNodeType());
assertFalse(decimalNode0.isIntegralNumber());
assertTrue(decimalNode0.isFloatingPointNumber());
assertFalse(decimalNode0.isDouble());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Class<MapperFeature> class0 = MapperFeature.class;
ObjectReader objectReader2 = objectReader0.withView(class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
byteArray0[1] = (byte)0;
byteArray0[2] = (byte) (-93);
byteArray0[3] = (byte) (-65);
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)100;
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders0.findFormat(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte) (-93), (byte) (-65), (byte)0, (byte)100}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(dataFormatReaders_Match0);
assertFalse(vector0.contains(objectReader1));
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
byte[] byteArray1 = new byte[0];
assertFalse(byteArray1.equals((Object)byteArray0));
DataFormatReaders.Match dataFormatReaders_Match1 = dataFormatReaders0.findFormat(byteArray1);
assertArrayEquals(new byte[] {}, byteArray1);
assertEquals(0, byteArray1.length);
assertFalse(byteArray1.equals((Object)byteArray0));
assertFalse(dataFormatReaders_Match1.equals((Object)dataFormatReaders_Match0));
assertNotNull(dataFormatReaders_Match1);
assertFalse(vector0.contains(objectReader1));
assertFalse(dataFormatReaders_Match1.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match1.getMatchStrength());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertTrue(vector0.isEmpty());
assertEquals(0, vector0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(byteArray1, byteArray0);
assertNotSame(dataFormatReaders_Match1, dataFormatReaders_Match0);
// Undeclared exception!
try {
objectReader0._detectBindAndReadValues(dataFormatReaders_Match1, false);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test225() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[3];
ObjectReader objectReader1 = objectMapper0.reader();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0._new(objectReader1, (DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test226() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
HashSet<String> hashSet0 = new HashSet<String>();
assertNotNull(hashSet0);
assertTrue(hashSet0.isEmpty());
assertEquals(0, hashSet0.size());
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
SimpleAbstractTypeResolver simpleAbstractTypeResolver0 = new SimpleAbstractTypeResolver();
assertNotNull(simpleAbstractTypeResolver0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAbstractTypeResolver(simpleAbstractTypeResolver0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DeserializationConfig deserializationConfig0 = defaultDeserializationContext_Impl0.getConfig();
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNull(deserializationConfig0);
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader0._new((ObjectReader) null, (DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test227() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<IntNode> class0 = IntNode.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
JsonpCharacterEscapes jsonpCharacterEscapes0 = JsonpCharacterEscapes.instance();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonFactory jsonFactory3 = jsonFactory2.copy();
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory3);
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
JsonFactory jsonFactory4 = objectReader1.getFactory();
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(jsonFactory4.equals((Object)jsonFactory0));
assertFalse(jsonFactory4.equals((Object)jsonFactory1));
assertFalse(jsonFactory4.equals((Object)jsonFactory2));
assertNotNull(jsonFactory4);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(8193, jsonFactory4.getParserFeatures());
assertTrue(jsonFactory4.canParseAsync());
assertEquals(31, jsonFactory4.getGeneratorFeatures());
assertEquals("JSON", jsonFactory4.getFormatName());
assertEquals(" ", jsonFactory4.getRootValueSeparator());
assertFalse(jsonFactory4.requiresPropertyOrdering());
assertEquals(0, jsonFactory4.getFormatGeneratorFeatures());
assertTrue(jsonFactory4.canUseCharArrays());
assertEquals(0, jsonFactory4.getFormatParserFeatures());
assertFalse(jsonFactory4.canHandleBinaryNatively());
assertFalse(jsonFactory4.requiresCustomCodec());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory4, jsonFactory3);
assertNotSame(jsonFactory4, jsonFactory0);
assertNotSame(jsonFactory4, jsonFactory1);
assertNotSame(jsonFactory4, jsonFactory2);
ObjectReader objectReader2 = objectReader1.withType(class0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
JsonParser.Feature[] jsonParser_FeatureArray0 = new JsonParser.Feature[3];
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
jsonParser_FeatureArray0[0] = jsonParser_Feature0;
JsonParser.Feature jsonParser_Feature1 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
jsonParser_FeatureArray0[1] = jsonParser_Feature1;
JsonParser.Feature jsonParser_Feature2 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
jsonParser_FeatureArray0[2] = jsonParser_Feature2;
ObjectReader objectReader3 = objectReader1.withoutFeatures(jsonParser_FeatureArray0);
assertEquals(3, jsonParser_FeatureArray0.length);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory3));
assertFalse(jsonFactory0.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory4));
assertFalse(jsonFactory1.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory3));
assertFalse(jsonFactory2.equals((Object)jsonFactory4));
assertFalse(jsonFactory3.equals((Object)jsonFactory0));
assertFalse(jsonFactory3.equals((Object)jsonFactory1));
assertFalse(jsonFactory3.equals((Object)jsonFactory2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory4);
assertNotSame(jsonFactory1, jsonFactory4);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory4);
assertSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory4);
assertNotSame(jsonFactory3, jsonFactory1);
assertNotSame(jsonFactory3, jsonFactory2);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader3);
}
@Test(timeout = 4000)
public void test228() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.with((TimeZone) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.cfg.BaseSettings", e);
}
}
@Test(timeout = 4000)
public void test229() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte) (-113);
byteArray0[2] = (byte)2;
byteArray0[3] = (byte)57;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)110;
byteArray0[6] = (byte) (-92);
byteArray0[7] = (byte)0;
byteArray0[8] = (byte)126;
try {
objectReader0.readValues(byteArray0, (int) 1, (int) 2);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 143)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\u0001\uFFFD\u00029\u0000n\uFFFD\u0000~\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test230() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
File file0 = MockFile.createTempFile("Object", "Instantiation of ");
assertNotNull(file0);
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/Object0Instantiation of ", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("Object0Instantiation of ", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
MockFile mockFile0 = new MockFile(file0, ">$[JC");
assertFalse(mockFile0.equals((Object)file0));
assertNotNull(mockFile0);
// Undeclared exception!
try {
objectReader0.readValue(file0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test231() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
assertNotNull(typeFactory0);
ClassLoader classLoader0 = ClassLoader.getSystemClassLoader();
assertNotNull(classLoader0);
TypeFactory typeFactory1 = typeFactory0.withClassLoader(classLoader0);
assertFalse(typeFactory1.equals((Object)typeFactory0));
assertNotNull(typeFactory1);
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(typeFactory1, typeFactory0);
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ArrayType arrayType0 = typeFactory0.constructArrayType(class0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertNotNull(arrayType0);
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertNotSame(typeFactory0, typeFactory1);
ArrayType arrayType1 = typeFactory0.constructArrayType((JavaType) arrayType0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(arrayType1.equals((Object)arrayType0));
assertNotNull(arrayType1);
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertTrue(arrayType1.hasContentType());
assertFalse(arrayType1.isPrimitive());
assertFalse(arrayType1.isInterface());
assertFalse(arrayType1.isAbstract());
assertTrue(arrayType1.isContainerType());
assertFalse(arrayType1.isJavaLangObject());
assertFalse(arrayType1.hasHandlers());
assertTrue(arrayType1.isFinal());
assertTrue(arrayType1.isConcrete());
assertTrue(arrayType1.isArrayType());
assertFalse(arrayType1.isEnumType());
assertEquals(0, arrayType1.containedTypeCount());
assertFalse(arrayType1.isCollectionLikeType());
assertFalse(arrayType1.useStaticType());
assertFalse(arrayType1.isMapLikeType());
assertFalse(arrayType1.hasValueHandler());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(arrayType0, arrayType1);
assertNotSame(arrayType1, arrayType0);
DoubleNode doubleNode0 = new DoubleNode(1.0);
assertNotNull(doubleNode0);
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isMissingNode());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isLong());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(doubleNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertTrue(doubleNode0.isDouble());
assertFalse(doubleNode0.isBigInteger());
assertEquals((short)1, doubleNode0.shortValue());
assertEquals(1, doubleNode0.intValue());
assertEquals(0, doubleNode0.size());
assertEquals(1.0, doubleNode0.doubleValue(), 0.01);
assertFalse(doubleNode0.booleanValue());
assertFalse(doubleNode0.isInt());
assertEquals(1L, doubleNode0.longValue());
assertFalse(doubleNode0.isShort());
assertTrue(doubleNode0.isEmpty());
assertTrue(doubleNode0.canConvertToLong());
assertEquals(1.0F, doubleNode0.floatValue(), 0.01F);
assertNull(doubleNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isObject());
assertTrue(doubleNode0.isFloatingPointNumber());
ArrayType arrayType2 = arrayType1.withContentValueHandler(doubleNode0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(arrayType0.equals((Object)arrayType1));
assertFalse(arrayType1.equals((Object)arrayType0));
assertTrue(arrayType2.equals((Object)arrayType1));
assertFalse(arrayType2.equals((Object)arrayType0));
assertNotNull(arrayType2);
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertTrue(arrayType1.hasContentType());
assertFalse(arrayType1.isPrimitive());
assertFalse(arrayType1.isInterface());
assertFalse(arrayType1.isAbstract());
assertTrue(arrayType1.isContainerType());
assertFalse(arrayType1.isJavaLangObject());
assertFalse(arrayType1.hasHandlers());
assertTrue(arrayType1.isFinal());
assertTrue(arrayType1.isConcrete());
assertTrue(arrayType1.isArrayType());
assertFalse(arrayType1.isEnumType());
assertEquals(0, arrayType1.containedTypeCount());
assertFalse(arrayType1.isCollectionLikeType());
assertFalse(arrayType1.useStaticType());
assertFalse(arrayType1.isMapLikeType());
assertFalse(arrayType1.hasValueHandler());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isMissingNode());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isLong());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(doubleNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertTrue(doubleNode0.isDouble());
assertFalse(doubleNode0.isBigInteger());
assertEquals((short)1, doubleNode0.shortValue());
assertEquals(1, doubleNode0.intValue());
assertEquals(0, doubleNode0.size());
assertEquals(1.0, doubleNode0.doubleValue(), 0.01);
assertFalse(doubleNode0.booleanValue());
assertFalse(doubleNode0.isInt());
assertEquals(1L, doubleNode0.longValue());
assertFalse(doubleNode0.isShort());
assertTrue(doubleNode0.isEmpty());
assertTrue(doubleNode0.canConvertToLong());
assertEquals(1.0F, doubleNode0.floatValue(), 0.01F);
assertNull(doubleNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isObject());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(arrayType2.isCollectionLikeType());
assertTrue(arrayType2.isConcrete());
assertTrue(arrayType2.isArrayType());
assertFalse(arrayType2.isEnumType());
assertFalse(arrayType2.isInterface());
assertEquals(0, arrayType2.containedTypeCount());
assertFalse(arrayType2.hasValueHandler());
assertFalse(arrayType2.isMapLikeType());
assertFalse(arrayType2.isAbstract());
assertFalse(arrayType2.useStaticType());
assertTrue(arrayType2.isFinal());
assertFalse(arrayType2.isJavaLangObject());
assertFalse(arrayType2.isPrimitive());
assertTrue(arrayType2.hasHandlers());
assertTrue(arrayType2.hasContentType());
assertTrue(arrayType2.isContainerType());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(arrayType0, arrayType2);
assertNotSame(arrayType0, arrayType1);
assertNotSame(arrayType1, arrayType2);
assertNotSame(arrayType1, arrayType0);
assertNotSame(arrayType2, arrayType0);
assertNotSame(arrayType2, arrayType1);
ArrayType arrayType3 = arrayType2.withValueHandler(doubleNode0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(arrayType0.equals((Object)arrayType2));
assertFalse(arrayType0.equals((Object)arrayType1));
assertTrue(arrayType1.equals((Object)arrayType2));
assertFalse(arrayType1.equals((Object)arrayType0));
assertTrue(arrayType2.equals((Object)arrayType1));
assertFalse(arrayType2.equals((Object)arrayType0));
assertTrue(arrayType3.equals((Object)arrayType2));
assertTrue(arrayType3.equals((Object)arrayType1));
assertFalse(arrayType3.equals((Object)arrayType0));
assertNotNull(arrayType3);
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertTrue(arrayType1.hasContentType());
assertFalse(arrayType1.isPrimitive());
assertFalse(arrayType1.isInterface());
assertFalse(arrayType1.isAbstract());
assertTrue(arrayType1.isContainerType());
assertFalse(arrayType1.isJavaLangObject());
assertFalse(arrayType1.hasHandlers());
assertTrue(arrayType1.isFinal());
assertTrue(arrayType1.isConcrete());
assertTrue(arrayType1.isArrayType());
assertFalse(arrayType1.isEnumType());
assertEquals(0, arrayType1.containedTypeCount());
assertFalse(arrayType1.isCollectionLikeType());
assertFalse(arrayType1.useStaticType());
assertFalse(arrayType1.isMapLikeType());
assertFalse(arrayType1.hasValueHandler());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isMissingNode());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isLong());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(doubleNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertTrue(doubleNode0.isDouble());
assertFalse(doubleNode0.isBigInteger());
assertEquals((short)1, doubleNode0.shortValue());
assertEquals(1, doubleNode0.intValue());
assertEquals(0, doubleNode0.size());
assertEquals(1.0, doubleNode0.doubleValue(), 0.01);
assertFalse(doubleNode0.booleanValue());
assertFalse(doubleNode0.isInt());
assertEquals(1L, doubleNode0.longValue());
assertFalse(doubleNode0.isShort());
assertTrue(doubleNode0.isEmpty());
assertTrue(doubleNode0.canConvertToLong());
assertEquals(1.0F, doubleNode0.floatValue(), 0.01F);
assertNull(doubleNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isObject());
assertTrue(doubleNode0.isFloatingPointNumber());
assertFalse(arrayType2.isCollectionLikeType());
assertTrue(arrayType2.isConcrete());
assertTrue(arrayType2.isArrayType());
assertFalse(arrayType2.isEnumType());
assertFalse(arrayType2.isInterface());
assertEquals(0, arrayType2.containedTypeCount());
assertFalse(arrayType2.hasValueHandler());
assertFalse(arrayType2.isMapLikeType());
assertFalse(arrayType2.isAbstract());
assertFalse(arrayType2.useStaticType());
assertTrue(arrayType2.isFinal());
assertFalse(arrayType2.isJavaLangObject());
assertFalse(arrayType2.isPrimitive());
assertTrue(arrayType2.hasHandlers());
assertTrue(arrayType2.hasContentType());
assertTrue(arrayType2.isContainerType());
assertFalse(arrayType3.isInterface());
assertTrue(arrayType3.hasContentType());
assertTrue(arrayType3.isFinal());
assertTrue(arrayType3.isContainerType());
assertFalse(arrayType3.isCollectionLikeType());
assertFalse(arrayType3.isMapLikeType());
assertFalse(arrayType3.isPrimitive());
assertFalse(arrayType3.isEnumType());
assertTrue(arrayType3.hasValueHandler());
assertEquals(0, arrayType3.containedTypeCount());
assertTrue(arrayType3.isArrayType());
assertTrue(arrayType3.hasHandlers());
assertFalse(arrayType3.isAbstract());
assertTrue(arrayType3.isConcrete());
assertFalse(arrayType3.useStaticType());
assertFalse(arrayType3.isJavaLangObject());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(arrayType0, arrayType2);
assertNotSame(arrayType0, arrayType3);
assertNotSame(arrayType0, arrayType1);
assertNotSame(arrayType1, arrayType3);
assertNotSame(arrayType1, arrayType2);
assertNotSame(arrayType1, arrayType0);
assertNotSame(arrayType2, arrayType0);
assertNotSame(arrayType2, arrayType1);
assertNotSame(arrayType2, arrayType3);
assertNotSame(arrayType3, arrayType1);
assertNotSame(arrayType3, arrayType2);
assertNotSame(arrayType3, arrayType0);
SerializerProvider serializerProvider0 = objectMapper0.getSerializerProvider();
assertFalse(serializerProvider0.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(serializerProvider0.equals((Object)defaultSerializerProvider_Impl1));
assertNotNull(serializerProvider0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(serializerProvider0, defaultSerializerProvider_Impl0);
assertNotSame(serializerProvider0, defaultSerializerProvider_Impl1);
JsonNode jsonNode0 = dOMSerializer0.getSchema(serializerProvider0, (Type) arrayType0);
assertFalse(typeFactory0.equals((Object)typeFactory1));
assertFalse(arrayType0.equals((Object)arrayType2));
assertFalse(arrayType0.equals((Object)arrayType3));
assertFalse(arrayType0.equals((Object)arrayType1));
assertFalse(serializerProvider0.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(serializerProvider0.equals((Object)defaultSerializerProvider_Impl1));
assertNotNull(jsonNode0);
assertEquals(1, jsonNode0.size());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.isFloat());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.booleanValue());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isMissingNode());
assertNull(jsonNode0.textValue());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(arrayType0.isEnumType());
assertEquals(0, arrayType0.containedTypeCount());
assertTrue(arrayType0.isContainerType());
assertFalse(arrayType0.hasHandlers());
assertFalse(arrayType0.isAbstract());
assertFalse(arrayType0.useStaticType());
assertTrue(arrayType0.isConcrete());
assertTrue(arrayType0.isFinal());
assertFalse(arrayType0.isJavaLangObject());
assertTrue(arrayType0.hasContentType());
assertFalse(arrayType0.isCollectionLikeType());
assertFalse(arrayType0.hasValueHandler());
assertFalse(arrayType0.isMapLikeType());
assertFalse(arrayType0.isInterface());
assertTrue(arrayType0.isArrayType());
assertFalse(arrayType0.isPrimitive());
assertNotSame(typeFactory0, typeFactory1);
assertNotSame(arrayType0, arrayType2);
assertNotSame(arrayType0, arrayType3);
assertNotSame(arrayType0, arrayType1);
assertNotSame(serializerProvider0, defaultSerializerProvider_Impl0);
assertNotSame(serializerProvider0, defaultSerializerProvider_Impl1);
JsonParser jsonParser0 = objectReader0.treeAsTokens(doubleNode0);
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertEquals(0, jsonParser0.currentTokenId());
assertNull(jsonParser0.getCurrentToken());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isMissingNode());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isLong());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(doubleNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertTrue(doubleNode0.isDouble());
assertFalse(doubleNode0.isBigInteger());
assertEquals((short)1, doubleNode0.shortValue());
assertEquals(1, doubleNode0.intValue());
assertEquals(0, doubleNode0.size());
assertEquals(1.0, doubleNode0.doubleValue(), 0.01);
assertFalse(doubleNode0.booleanValue());
assertFalse(doubleNode0.isInt());
assertEquals(1L, doubleNode0.longValue());
assertFalse(doubleNode0.isShort());
assertTrue(doubleNode0.isEmpty());
assertTrue(doubleNode0.canConvertToLong());
assertEquals(1.0F, doubleNode0.floatValue(), 0.01F);
assertNull(doubleNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isObject());
assertTrue(doubleNode0.isFloatingPointNumber());
DoubleNode doubleNode1 = (DoubleNode)objectReader0._bindAndCloseAsTree(jsonParser0);
assertTrue(doubleNode1.equals((Object)doubleNode0));
assertNotNull(doubleNode1);
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertTrue(jsonParser0.isClosed());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertEquals(0, jsonParser0.currentTokenId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadObjectId());
assertNull(doubleNode1.textValue());
assertTrue(doubleNode1.isEmpty());
assertTrue(doubleNode1.isDouble());
assertFalse(doubleNode1.isMissingNode());
assertTrue(doubleNode1.canConvertToInt());
assertFalse(doubleNode1.isShort());
assertTrue(doubleNode1.isFloatingPointNumber());
assertFalse(doubleNode1.isObject());
assertEquals(1.0F, doubleNode1.floatValue(), 0.01F);
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode1.numberType());
assertTrue(doubleNode1.canConvertToLong());
assertFalse(doubleNode1.isLong());
assertFalse(doubleNode1.isFloat());
assertFalse(doubleNode1.isIntegralNumber());
assertEquals((short)1, doubleNode1.shortValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode1.asToken());
assertFalse(doubleNode1.isBigInteger());
assertFalse(doubleNode1.isBigDecimal());
assertFalse(doubleNode1.isNaN());
assertEquals(1L, doubleNode1.longValue());
assertFalse(doubleNode1.isInt());
assertFalse(doubleNode1.isArray());
assertFalse(doubleNode1.booleanValue());
assertEquals(0, doubleNode1.size());
assertEquals(1, doubleNode1.intValue());
assertEquals(1.0, doubleNode1.doubleValue(), 0.01);
assertEquals(JsonNodeType.NUMBER, doubleNode1.getNodeType());
assertFalse(doubleNode0.isArray());
assertFalse(doubleNode0.isMissingNode());
assertEquals(JsonNodeType.NUMBER, doubleNode0.getNodeType());
assertFalse(doubleNode0.isLong());
assertFalse(doubleNode0.isIntegralNumber());
assertTrue(doubleNode0.canConvertToInt());
assertEquals(JsonParser.NumberType.DOUBLE, doubleNode0.numberType());
assertTrue(doubleNode0.isDouble());
assertFalse(doubleNode0.isBigInteger());
assertEquals((short)1, doubleNode0.shortValue());
assertEquals(1, doubleNode0.intValue());
assertEquals(0, doubleNode0.size());
assertEquals(1.0, doubleNode0.doubleValue(), 0.01);
assertFalse(doubleNode0.booleanValue());
assertFalse(doubleNode0.isInt());
assertEquals(1L, doubleNode0.longValue());
assertFalse(doubleNode0.isShort());
assertTrue(doubleNode0.isEmpty());
assertTrue(doubleNode0.canConvertToLong());
assertEquals(1.0F, doubleNode0.floatValue(), 0.01F);
assertNull(doubleNode0.textValue());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, doubleNode0.asToken());
assertFalse(doubleNode0.isFloat());
assertFalse(doubleNode0.isBigDecimal());
assertFalse(doubleNode0.isNaN());
assertFalse(doubleNode0.isObject());
assertTrue(doubleNode0.isFloatingPointNumber());
assertNotSame(doubleNode1, doubleNode0);
assertNotSame(doubleNode0, doubleNode1);
// Undeclared exception!
try {
objectReader0.readValues((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test232() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[6];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(6, byteArrayInputStream0.available());
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
assertEquals(1, deserializationFeatureArray0.length);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<CollectionType> class0 = CollectionType.class;
TypeBindings typeBindings0 = TypeBindings.emptyBindings();
assertNotNull(typeBindings0);
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
JavaType javaType0 = TypeFactory.unknownType();
assertNotNull(javaType0);
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
CollectionLikeType collectionLikeType0 = CollectionLikeType.upgradeFrom(javaType0, javaType0);
assertNotNull(collectionLikeType0);
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
JavaType[] javaTypeArray0 = new JavaType[4];
javaTypeArray0[0] = javaType0;
javaTypeArray0[1] = javaType0;
javaTypeArray0[2] = javaType0;
javaTypeArray0[3] = (JavaType) collectionLikeType0;
ReferenceType referenceType0 = ReferenceType.construct((Class<?>) class0, typeBindings0, (JavaType) collectionLikeType0, javaTypeArray0, javaType0);
assertEquals(4, javaTypeArray0.length);
assertNotNull(referenceType0);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
Class<NullNode> class1 = NullNode.class;
MapType mapType0 = MapType.construct((Class<?>) class1, typeBindings0, (JavaType) collectionLikeType0, javaTypeArray0, javaTypeArray0[2], (JavaType) referenceType0);
assertEquals(4, javaTypeArray0.length);
assertNotNull(mapType0);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
PlaceholderForType placeholderForType0 = new PlaceholderForType((-979));
assertNotNull(placeholderForType0);
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
MapType mapType1 = mapType0.withKeyType(placeholderForType0);
assertEquals(4, javaTypeArray0.length);
assertFalse(mapType1.equals((Object)mapType0));
assertNotNull(mapType1);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
ReferenceType referenceType1 = referenceType0.withContentTypeHandler(mapType1);
assertEquals(4, javaTypeArray0.length);
assertFalse(mapType0.equals((Object)mapType1));
assertFalse(mapType1.equals((Object)mapType0));
assertTrue(referenceType1.equals((Object)referenceType0));
assertNotNull(referenceType1);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.isJavaLangObject());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(referenceType0, referenceType1);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(referenceType1, referenceType0);
ReferenceType referenceType2 = referenceType1.withStaticTyping();
assertEquals(4, javaTypeArray0.length);
assertTrue(referenceType0.equals((Object)referenceType1));
assertFalse(mapType0.equals((Object)mapType1));
assertFalse(mapType1.equals((Object)mapType0));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertNotNull(referenceType2);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.hasHandlers());
assertTrue(referenceType2.isReferenceType());
assertFalse(referenceType2.isArrayType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAnchorType());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isEnumType());
assertTrue(referenceType2.useStaticType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertTrue(referenceType2.isFinal());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isAbstract());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
ReferenceType referenceType3 = referenceType2.withTypeHandler(javaType0);
assertEquals(4, javaTypeArray0.length);
assertTrue(referenceType0.equals((Object)referenceType2));
assertTrue(referenceType0.equals((Object)referenceType1));
assertFalse(mapType0.equals((Object)mapType1));
assertFalse(mapType1.equals((Object)mapType0));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType3.equals((Object)referenceType2));
assertTrue(referenceType3.equals((Object)referenceType1));
assertTrue(referenceType3.equals((Object)referenceType0));
assertNotNull(referenceType3);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.hasHandlers());
assertTrue(referenceType2.isReferenceType());
assertFalse(referenceType2.isArrayType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAnchorType());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isEnumType());
assertTrue(referenceType2.useStaticType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertTrue(referenceType2.isFinal());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isAbstract());
assertFalse(referenceType3.isPrimitive());
assertFalse(referenceType3.isMapLikeType());
assertTrue(referenceType3.isReferenceType());
assertEquals(0, referenceType3.containedTypeCount());
assertFalse(referenceType3.isInterface());
assertFalse(referenceType3.isAnchorType());
assertFalse(referenceType3.isArrayType());
assertFalse(referenceType3.hasValueHandler());
assertTrue(referenceType3.useStaticType());
assertFalse(referenceType3.isContainerType());
assertFalse(referenceType3.isEnumType());
assertFalse(referenceType3.isAbstract());
assertFalse(referenceType3.isCollectionLikeType());
assertFalse(referenceType3.isJavaLangObject());
assertTrue(referenceType3.isConcrete());
assertTrue(referenceType3.hasContentType());
assertTrue(referenceType3.isFinal());
assertTrue(referenceType3.hasHandlers());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(referenceType0, referenceType3);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType1, referenceType3);
assertNotSame(referenceType2, referenceType3);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
assertNotSame(referenceType3, referenceType0);
assertNotSame(referenceType3, referenceType2);
assertNotSame(referenceType3, referenceType1);
String string0 = referenceType2.getGenericSignature();
assertEquals("Lcom/fasterxml/jackson/databind/type/CollectionType<Ljava/lang/Object;>;", string0);
assertEquals(4, javaTypeArray0.length);
assertTrue(referenceType0.equals((Object)referenceType2));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType3));
assertFalse(mapType0.equals((Object)mapType1));
assertFalse(mapType1.equals((Object)mapType0));
assertTrue(referenceType1.equals((Object)referenceType3));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType3));
assertNotNull(string0);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.hasHandlers());
assertTrue(referenceType2.isReferenceType());
assertFalse(referenceType2.isArrayType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAnchorType());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isEnumType());
assertTrue(referenceType2.useStaticType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertTrue(referenceType2.isFinal());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isAbstract());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(referenceType0, referenceType3);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType1, referenceType3);
assertNotSame(referenceType2, referenceType3);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
ReferenceType referenceType4 = referenceType3.withContentValueHandler(deserializationFeature0);
assertEquals(4, javaTypeArray0.length);
assertTrue(referenceType0.equals((Object)referenceType2));
assertTrue(referenceType0.equals((Object)referenceType1));
assertTrue(referenceType0.equals((Object)referenceType3));
assertFalse(mapType0.equals((Object)mapType1));
assertFalse(mapType1.equals((Object)mapType0));
assertTrue(referenceType1.equals((Object)referenceType3));
assertTrue(referenceType1.equals((Object)referenceType2));
assertTrue(referenceType1.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType1));
assertTrue(referenceType2.equals((Object)referenceType0));
assertTrue(referenceType2.equals((Object)referenceType3));
assertTrue(referenceType3.equals((Object)referenceType2));
assertTrue(referenceType3.equals((Object)referenceType1));
assertTrue(referenceType3.equals((Object)referenceType0));
assertTrue(referenceType4.equals((Object)referenceType2));
assertTrue(referenceType4.equals((Object)referenceType1));
assertTrue(referenceType4.equals((Object)referenceType3));
assertTrue(referenceType4.equals((Object)referenceType0));
assertNotNull(referenceType4);
assertFalse(referenceType0.hasValueHandler());
assertFalse(referenceType0.isJavaLangObject());
assertFalse(referenceType0.useStaticType());
assertEquals(0, referenceType0.containedTypeCount());
assertTrue(referenceType0.hasContentType());
assertFalse(referenceType0.isPrimitive());
assertFalse(referenceType0.hasHandlers());
assertTrue(referenceType0.isAnchorType());
assertFalse(referenceType0.isCollectionLikeType());
assertFalse(referenceType0.isMapLikeType());
assertFalse(referenceType0.isContainerType());
assertFalse(referenceType0.isInterface());
assertFalse(referenceType0.isEnumType());
assertTrue(referenceType0.isConcrete());
assertTrue(referenceType0.isReferenceType());
assertFalse(referenceType0.isArrayType());
assertTrue(referenceType0.isFinal());
assertFalse(referenceType0.isAbstract());
assertFalse(mapType0.isEnumType());
assertEquals(0, mapType0.containedTypeCount());
assertTrue(mapType0.isMapLikeType());
assertFalse(mapType0.useStaticType());
assertTrue(mapType0.isFinal());
assertFalse(mapType0.isAbstract());
assertFalse(mapType0.isJavaLangObject());
assertTrue(mapType0.isConcrete());
assertFalse(mapType0.isArrayType());
assertTrue(mapType0.hasContentType());
assertFalse(mapType0.isCollectionLikeType());
assertFalse(mapType0.hasHandlers());
assertFalse(mapType0.hasValueHandler());
assertFalse(mapType0.isPrimitive());
assertTrue(mapType0.isContainerType());
assertFalse(mapType0.isInterface());
assertTrue(placeholderForType0.isJavaLangObject());
assertEquals(0, placeholderForType0.containedTypeCount());
assertFalse(placeholderForType0.isAbstract());
assertFalse(placeholderForType0.isEnumType());
assertFalse(placeholderForType0.isContainerType());
assertFalse(placeholderForType0.isInterface());
assertTrue(placeholderForType0.hasContentType());
assertFalse(placeholderForType0.isFinal());
assertTrue(placeholderForType0.isConcrete());
assertFalse(placeholderForType0.hasHandlers());
assertFalse(placeholderForType0.isCollectionLikeType());
assertFalse(placeholderForType0.isMapLikeType());
assertFalse(placeholderForType0.useStaticType());
assertFalse(placeholderForType0.isPrimitive());
assertFalse(placeholderForType0.hasValueHandler());
assertFalse(placeholderForType0.isArrayType());
assertTrue(mapType1.isMapLikeType());
assertTrue(mapType1.isContainerType());
assertFalse(mapType1.isCollectionLikeType());
assertFalse(mapType1.isEnumType());
assertFalse(mapType1.isAbstract());
assertFalse(mapType1.isJavaLangObject());
assertTrue(mapType1.isConcrete());
assertFalse(mapType1.isPrimitive());
assertTrue(mapType1.isFinal());
assertTrue(mapType1.hasContentType());
assertFalse(mapType1.hasHandlers());
assertFalse(mapType1.isInterface());
assertFalse(mapType1.hasValueHandler());
assertFalse(mapType1.useStaticType());
assertEquals(0, mapType1.containedTypeCount());
assertFalse(mapType1.isArrayType());
assertEquals(0, referenceType1.containedTypeCount());
assertFalse(referenceType1.hasValueHandler());
assertTrue(referenceType1.hasContentType());
assertFalse(referenceType1.useStaticType());
assertFalse(referenceType1.isMapLikeType());
assertFalse(referenceType1.isContainerType());
assertFalse(referenceType1.isCollectionLikeType());
assertFalse(referenceType1.isEnumType());
assertFalse(referenceType1.isAnchorType());
assertFalse(referenceType1.isInterface());
assertFalse(referenceType1.isPrimitive());
assertFalse(referenceType1.isArrayType());
assertFalse(referenceType1.hasHandlers());
assertTrue(referenceType1.isReferenceType());
assertFalse(referenceType1.isAbstract());
assertTrue(referenceType1.isConcrete());
assertTrue(referenceType1.isFinal());
assertFalse(referenceType1.isJavaLangObject());
assertFalse(referenceType2.isInterface());
assertFalse(referenceType2.hasHandlers());
assertTrue(referenceType2.isReferenceType());
assertFalse(referenceType2.isArrayType());
assertFalse(referenceType2.isContainerType());
assertFalse(referenceType2.isMapLikeType());
assertFalse(referenceType2.isCollectionLikeType());
assertFalse(referenceType2.isAnchorType());
assertFalse(referenceType2.isPrimitive());
assertFalse(referenceType2.isEnumType());
assertTrue(referenceType2.useStaticType());
assertEquals(0, referenceType2.containedTypeCount());
assertTrue(referenceType2.hasContentType());
assertFalse(referenceType2.hasValueHandler());
assertTrue(referenceType2.isFinal());
assertTrue(referenceType2.isConcrete());
assertFalse(referenceType2.isJavaLangObject());
assertFalse(referenceType2.isAbstract());
assertFalse(referenceType3.isPrimitive());
assertFalse(referenceType3.isMapLikeType());
assertTrue(referenceType3.isReferenceType());
assertEquals(0, referenceType3.containedTypeCount());
assertFalse(referenceType3.isInterface());
assertFalse(referenceType3.isAnchorType());
assertFalse(referenceType3.isArrayType());
assertFalse(referenceType3.hasValueHandler());
assertTrue(referenceType3.useStaticType());
assertFalse(referenceType3.isContainerType());
assertFalse(referenceType3.isEnumType());
assertFalse(referenceType3.isAbstract());
assertFalse(referenceType3.isCollectionLikeType());
assertFalse(referenceType3.isJavaLangObject());
assertTrue(referenceType3.isConcrete());
assertTrue(referenceType3.hasContentType());
assertTrue(referenceType3.isFinal());
assertTrue(referenceType3.hasHandlers());
assertEquals(0, typeBindings0.size());
assertTrue(typeBindings0.isEmpty());
assertFalse(referenceType4.isContainerType());
assertFalse(referenceType4.isEnumType());
assertFalse(referenceType4.isAbstract());
assertFalse(referenceType4.isCollectionLikeType());
assertFalse(referenceType4.isJavaLangObject());
assertTrue(referenceType4.isConcrete());
assertTrue(referenceType4.hasContentType());
assertTrue(referenceType4.isFinal());
assertTrue(referenceType4.hasHandlers());
assertFalse(referenceType4.isPrimitive());
assertFalse(referenceType4.isMapLikeType());
assertTrue(referenceType4.isReferenceType());
assertEquals(0, referenceType4.containedTypeCount());
assertFalse(referenceType4.isInterface());
assertFalse(referenceType4.isAnchorType());
assertFalse(referenceType4.isArrayType());
assertFalse(referenceType4.hasValueHandler());
assertTrue(referenceType4.useStaticType());
assertFalse(javaType0.isFinal());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isCollectionLikeType());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.hasValueHandler());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.isAbstract());
assertFalse(javaType0.useStaticType());
assertFalse(collectionLikeType0.hasValueHandler());
assertFalse(collectionLikeType0.useStaticType());
assertFalse(collectionLikeType0.isArrayType());
assertTrue(collectionLikeType0.isContainerType());
assertTrue(collectionLikeType0.isJavaLangObject());
assertEquals(0, collectionLikeType0.containedTypeCount());
assertFalse(collectionLikeType0.hasHandlers());
assertFalse(collectionLikeType0.isAbstract());
assertTrue(collectionLikeType0.isConcrete());
assertFalse(collectionLikeType0.isFinal());
assertTrue(collectionLikeType0.isCollectionLikeType());
assertFalse(collectionLikeType0.isPrimitive());
assertTrue(collectionLikeType0.hasContentType());
assertFalse(collectionLikeType0.isMapLikeType());
assertFalse(collectionLikeType0.isInterface());
assertFalse(collectionLikeType0.isEnumType());
assertNotSame(referenceType0, referenceType3);
assertNotSame(referenceType0, referenceType1);
assertNotSame(referenceType0, referenceType2);
assertNotSame(referenceType0, referenceType4);
assertNotSame(mapType0, mapType1);
assertNotSame(mapType1, mapType0);
assertNotSame(referenceType1, referenceType0);
assertNotSame(referenceType1, referenceType2);
assertNotSame(referenceType1, referenceType4);
assertNotSame(referenceType1, referenceType3);
assertNotSame(referenceType2, referenceType3);
assertNotSame(referenceType2, referenceType0);
assertNotSame(referenceType2, referenceType1);
assertNotSame(referenceType2, referenceType4);
assertNotSame(referenceType3, referenceType4);
assertNotSame(referenceType3, referenceType0);
assertNotSame(referenceType3, referenceType2);
assertNotSame(referenceType3, referenceType1);
assertNotSame(referenceType4, referenceType0);
assertNotSame(referenceType4, referenceType2);
assertNotSame(referenceType4, referenceType1);
assertNotSame(referenceType4, referenceType3);
// Undeclared exception!
try {
objectReader0.forType((JavaType) referenceType4);
fail("Expecting exception: ClassCastException");
} catch(ClassCastException e) {
//
// com.fasterxml.jackson.databind.DeserializationFeature cannot be cast to com.fasterxml.jackson.databind.JsonDeserializer
//
verifyException("com.fasterxml.jackson.databind.deser.BasicDeserializerFactory", e);
}
}
@Test(timeout = 4000)
public void test233() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
StringReader stringReader0 = new StringReader(" for format ");
assertNotNull(stringReader0);
try {
objectReader1.readValues((Reader) stringReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'for': was expecting 'null', 'true', 'false' or NaN
// at [Source: (StringReader); line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test234() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-50);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-50)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-50)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.booleanValue());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.booleanValue());
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(1, BufferRecycler.CHAR_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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-50)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.booleanValue());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
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);
ObjectMapper objectMapper1 = objectMapper0.clearProblemHandlers();
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertNotNull(defaultSerializerProvider_Impl1);
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_MISSING_VALUES;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
Class<? extends FormatFeature> class0 = jsonFactory1.getFormatWriteFeatureType();
assertNull(class0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonNode jsonNode0 = dOMSerializer0.getSchema((SerializerProvider) defaultSerializerProvider_Impl1, (Type) null);
assertFalse(defaultSerializerProvider_Impl1.equals((Object)defaultSerializerProvider_Impl0));
assertFalse(defaultSerializerProvider_Impl0.equals((Object)defaultSerializerProvider_Impl1));
assertNotNull(jsonNode0);
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isArray());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.booleanValue());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isMissingNode());
assertNull(jsonNode0.textValue());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertEquals(1, jsonNode0.size());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertNotSame(defaultSerializerProvider_Impl1, defaultSerializerProvider_Impl0);
assertNotSame(defaultSerializerProvider_Impl0, defaultSerializerProvider_Impl1);
JsonParser jsonParser0 = objectReader0.treeAsTokens(booleanNode0);
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonParser0.hasCurrentToken());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canParseAsync());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.booleanValue());
assertSame(objectMapper0, objectMapper1);
try {
objectReader0._bindAndCloseAsTree(readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'entries': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test235() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[0];
JsonNode jsonNode0 = objectReader0.readTree(byteArray0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals("", jsonNode0.asText());
assertEquals(0, jsonNode0.size());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isArray());
assertNull(jsonNode0.textValue());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
assertNotNull(objectNode0);
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isArray());
assertEquals("", objectNode0.asText());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
// Undeclared exception!
try {
objectReader0._findRootDeserializer((DeserializationContext) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test236() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(objectMapper0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte) (-34);
byteArray0[1] = (byte)1;
// Undeclared exception!
try {
objectReader1.readTree(byteArray0, (-848), (int) (byte)1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -848
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test237() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonParser.Feature[] jsonParser_FeatureArray0 = new JsonParser.Feature[1];
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
jsonParser_FeatureArray0[0] = jsonParser_Feature0;
ObjectReader objectReader1 = objectReader0.withFeatures(jsonParser_FeatureArray0);
assertEquals(1, jsonParser_FeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test238() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
// Undeclared exception!
try {
objectReader0.readTree((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test239() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[5];
ObjectReader[] objectReaderArray0 = new ObjectReader[2];
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
objectReaderArray0[0] = objectReader0;
Class<POJONode> class0 = POJONode.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
objectReaderArray0[1] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(2, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
String string0 = dataFormatReaders0.toString();
assertEquals("[JSON, JSON]", string0);
assertEquals(2, objectReaderArray0.length);
assertNotNull(string0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isConcrete());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
assertEquals(2, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isConcrete());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders0.withMaxInputLookahead(64);
assertEquals(2, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertSame(dataFormatReaders2, dataFormatReaders0);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
try {
objectReader0.readValues(byteArray0);
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: (byte[])\"\u0000\u0000\u0000\u0000\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test240() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader((JsonNodeFactory) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES;
ObjectReader objectReader1 = objectReader0.without(deserializationFeature0);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "$EtA#nGWt7");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ObjectReader objectReader2 = objectReader0.with(contextAttributes0);
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader0, objectReader2);
assertSame(objectReader2, objectReader0);
assertSame(objectReader2, objectReader1);
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertNotNull(typeFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader0, objectReader2);
assertSame(objectReader1, objectReader0);
assertSame(objectReader1, objectReader2);
Class<LongNode> class0 = LongNode.class;
ObjectReader objectReader3 = objectReader1.forType(class0);
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader3);
assertSame(objectReader1, objectReader0);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
SimpleKeyDeserializers simpleKeyDeserializers0 = new SimpleKeyDeserializers();
assertNotNull(simpleKeyDeserializers0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAdditionalKeyDeserializers(simpleKeyDeserializers0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JsonParser jsonParser0 = defaultDeserializationContext_Impl0.getParser();
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNull(jsonParser0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader2._bind((JsonParser) null, beanDeserializerFactory0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test241() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertNotNull(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
PushbackInputStream pushbackInputStream0 = new PushbackInputStream(pipedInputStream0);
assertNotNull(pushbackInputStream0);
assertEquals(0, pipedInputStream0.available());
try {
objectReader0.readValues((InputStream) pushbackInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedInputStream", e);
}
}
@Test(timeout = 4000)
public void test242() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNode jsonNode0 = objectReader0.readTree("");
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isFloat());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isBigDecimal());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isIntegralNumber());
assertTrue(jsonNode0.isEmpty());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
JsonNode jsonNode1 = objectReader0.readTree((InputStream) null);
assertNotNull(jsonNode1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonNode1.isEmpty());
assertFalse(jsonNode1.isBigInteger());
assertFalse(jsonNode1.isBigDecimal());
assertFalse(jsonNode1.isObject());
assertNull(jsonNode1.textValue());
assertEquals("", jsonNode1.asText());
assertTrue(jsonNode1.isMissingNode());
assertFalse(jsonNode1.isInt());
assertFalse(jsonNode1.isShort());
assertFalse(jsonNode1.isDouble());
assertFalse(jsonNode1.isLong());
assertEquals(JsonNodeType.MISSING, jsonNode1.getNodeType());
assertEquals(0, jsonNode1.size());
assertNull(jsonNode1.numberType());
assertFalse(jsonNode1.booleanValue());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode1.asToken());
assertFalse(jsonNode1.isIntegralNumber());
assertFalse(jsonNode1.isArray());
assertFalse(jsonNode1.isFloat());
assertFalse(jsonNode1.isFloatingPointNumber());
assertSame(jsonNode1, jsonNode0);
PropertyName propertyName0 = new PropertyName("Cannot detect format from input, does not look like any of detectable formats ");
assertNotNull(propertyName0);
assertFalse(propertyName0.hasNamespace());
assertEquals("Cannot detect format from input, does not look like any of detectable formats ", propertyName0.getSimpleName());
assertNull(propertyName0.getNamespace());
assertTrue(propertyName0.hasSimpleName());
assertFalse(propertyName0.isEmpty());
ObjectReader objectReader1 = objectReader0.withRootName(propertyName0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(propertyName0.hasNamespace());
assertEquals("Cannot detect format from input, does not look like any of detectable formats ", propertyName0.getSimpleName());
assertNull(propertyName0.getNamespace());
assertTrue(propertyName0.hasSimpleName());
assertFalse(propertyName0.isEmpty());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test243() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-17);
byteArray0[1] = (byte) (-8);
byteArray0[2] = (byte) (-8);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(4, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
String string0 = dataFormatReaders0.toString();
assertEquals("[JSON, JSON, JSON, JSON]", string0);
assertEquals(4, objectReaderArray0.length);
assertNotNull(string0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
byte[] byteArray1 = new byte[3];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte) (-8);
byteArray1[1] = (byte) (-8);
byteArray1[2] = (byte) (-17);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray1, (byte) (-17), (byte) (-8));
assertArrayEquals(new byte[] {(byte) (-8), (byte) (-8), (byte) (-17)}, byteArray1);
assertEquals(3, byteArray1.length);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(byteArrayInputStream0);
assertEquals((-8), byteArrayInputStream0.available());
File file0 = MockFile.createTempFile("[JSON, JSON, JSON, JSON]", "Instantiation of ");
assertNotNull(file0);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("[JSON, JSON, JSON, JSON]0Instantiation of ", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals("/tmp/[JSON, JSON, JSON, JSON]0Instantiation of ", file0.toString());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertTrue(file0.isFile());
MockFile mockFile0 = new MockFile(file0, "Current token not START_OBJECT (needed to unwrap root name '%s'), but %s");
assertFalse(mockFile0.equals((Object)file0));
assertNotNull(mockFile0);
try {
objectReader0.readValue((File) mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test244() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = null;
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
assertNotNull(jsonFactory2);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(63, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(63, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(63, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonFactory jsonFactory3 = jsonFactory2.setRootValueSeparator("");
assertNotNull(jsonFactory3);
assertEquals("", jsonFactory0.getRootValueSeparator());
assertEquals(63, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(63, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("", jsonFactory1.getRootValueSeparator());
assertEquals("", jsonFactory2.getRootValueSeparator());
assertEquals(63, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(63, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals("", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
MockFile mockFile0 = new MockFile(">PU`s5z6L");
assertNotNull(mockFile0);
File file0 = MockFile.createTempFile("JSON", ">PU`s5z6L", (File) mockFile0);
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(file0);
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertTrue(mockFile0.isDirectory());
assertFalse(mockFile0.isFile());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertEquals(">PU`s5z6L", mockFile0.getName());
assertTrue(mockFile0.canExecute());
assertEquals(">PU`s5z6L", mockFile0.toString());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.exists());
assertTrue(file0.canExecute());
assertEquals("JSON0>PU`s5z6L", file0.getName());
assertEquals("/experiment/>PU`s5z6L", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/experiment/>PU`s5z6L/JSON0>PU`s5z6L", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotSame(mockFile0, file0);
assertNotSame(file0, mockFile0);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory3.createParser(file0);
assertFalse(mockFile0.equals((Object)file0));
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(uTF8StreamJsonParser0);
assertEquals("", jsonFactory0.getRootValueSeparator());
assertEquals(63, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(63, jsonFactory1.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("", jsonFactory1.getRootValueSeparator());
assertEquals("", jsonFactory2.getRootValueSeparator());
assertEquals(63, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(63, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals("", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertTrue(mockFile0.isDirectory());
assertFalse(mockFile0.isFile());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertEquals(">PU`s5z6L", mockFile0.getName());
assertTrue(mockFile0.canExecute());
assertEquals(">PU`s5z6L", mockFile0.toString());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.exists());
assertTrue(file0.canExecute());
assertEquals("JSON0>PU`s5z6L", file0.getName());
assertEquals("/experiment/>PU`s5z6L", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/experiment/>PU`s5z6L/JSON0>PU`s5z6L", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(mockFile0, file0);
assertNotSame(file0, mockFile0);
// Undeclared exception!
try {
objectReader0._bindAndClose(uTF8StreamJsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test245() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[0];
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
Class<NullNode> class0 = NullNode.class;
Class<DoubleNode> class1 = DoubleNode.class;
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class1, (Object) class0);
assertNotNull(injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
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);
ObjectReader objectReader2 = objectMapper1.readerForUpdating(injectableValues_Std1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayBuilder0.size());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals("ftp", uRL0.getProtocol());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertNull(uRL0.getQuery());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DeserializationConfig deserializationConfig0 = defaultDeserializationContext_Impl0.getConfig();
assertNull(deserializationConfig0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
// Undeclared exception!
try {
objectReader1.with((DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test246() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[0];
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
Class<NullNode> class0 = NullNode.class;
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
Class<DoubleNode> class1 = DoubleNode.class;
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class1, (Object) class0);
assertNotNull(injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
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);
ObjectReader objectReader2 = objectMapper1.readerForUpdating(injectableValues_Std1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, objectReader2, false);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(iOContext0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertNull(iOContext0.getEncoding());
assertFalse(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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
ObjectReader[] objectReaderArray0 = new ObjectReader[5];
objectReaderArray0[0] = objectReader2;
objectReaderArray0[1] = objectReader0;
Class<PlaceholderForType> class2 = PlaceholderForType.class;
ObjectReader objectReader3 = objectMapper0.readerFor(class2);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
objectReaderArray0[2] = objectReader3;
objectReaderArray0[3] = objectReader2;
objectReaderArray0[4] = objectReader2;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(5, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
String string0 = dataFormatReaders0.toString();
assertEquals("[JSON, JSON, JSON, JSON, JSON]", string0);
assertEquals(5, objectReaderArray0.length);
assertNotNull(string0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<MapType> class3 = MapType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class3);
assertNotNull(simpleType0);
assertFalse(simpleType0.isPrimitive());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isEnumType());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
assertEquals(5, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(simpleType0.isPrimitive());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isArrayType());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isEnumType());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders0.withMaxInputLookahead(1);
assertEquals(5, objectReaderArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
MappingIterator<SimpleObjectIdResolver> mappingIterator0 = objectReader2.readValues(byteArray0);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader3));
assertNotNull(mappingIterator0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader3);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
assertNotNull(objectNode0);
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(0, objectNode0.size());
JsonNode jsonNode0 = objectNode0.replace("G", (JsonNode) null);
assertNull(jsonNode0);
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isBigDecimal());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.booleanValue());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isFloat());
assertEquals(1, objectNode0.size());
// Undeclared exception!
try {
objectReader2.treeAsTokens((TreeNode) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.node.TreeTraversingParser", e);
}
}
@Test(timeout = 4000)
public void test247() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
try {
objectReader0.readTree((InputStream) byteArrayInputStream0);
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: (ByteArrayInputStream); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test248() throws Throwable {
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readTree((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test249() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)0;
boolean boolean1 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean1);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(2, byteArray0.length);
assertTrue(boolean1 == boolean0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
Class<NullNode> class0 = NullNode.class;
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class0, (Object) class0);
assertNotNull(injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std1);
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
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, objectMapper0, false);
assertNotNull(iOContext0);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.size());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-1), objectMapper0, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, (byte)0, false);
assertNotNull(uTF8JsonGenerator0);
assertEquals(0, byteArrayBuilder0.size());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-1), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
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);
FormatSchema formatSchema0 = uTF8JsonGenerator0.getSchema();
assertNull(formatSchema0);
assertEquals(0, byteArrayBuilder0.size());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-1), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
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);
assertSame(jsonFactory0, jsonFactory1);
ObjectReader objectReader2 = objectReader1.with((FormatSchema) null);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
assertNull(uRL0.getUserInfo());
assertEquals((-1), uRL0.getDefaultPort());
assertNull(uRL0.getRef());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getQuery());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals((-1), uRL0.getPort());
// Undeclared exception!
try {
objectReader2._inputStream(uRL0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test250() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
String string0 = dataFormatReaders0.toString();
assertEquals("[]", string0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(string0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMinimalMatch(matchStrength0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(dataFormatReaders0, dataFormatReaders1);
assertSame(dataFormatReaders1, dataFormatReaders0);
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isAbstract());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.isPrimitive());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.useStaticType());
DataFormatReaders dataFormatReaders2 = dataFormatReaders0.withMaxInputLookahead(1);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null, 64, 1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test251() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "S?<NE4");
assertFalse(boolean0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper1.readerFor(class0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
SimpleAbstractTypeResolver simpleAbstractTypeResolver0 = new SimpleAbstractTypeResolver();
assertNotNull(simpleAbstractTypeResolver0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAbstractTypeResolver(simpleAbstractTypeResolver0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JsonParser jsonParser0 = defaultDeserializationContext_Impl0.getParser();
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNull(jsonParser0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader0._bindAndReadValues((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test252() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JavaType javaType0 = null;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[0];
ObjectReader objectReader1 = objectReader0.withoutFeatures(deserializationFeatureArray0);
assertEquals(0, deserializationFeatureArray0.length);
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
// Undeclared exception!
try {
ReferenceType.upgradeFrom((JavaType) null, (JavaType) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Missing referencedType
//
verifyException("com.fasterxml.jackson.databind.type.ReferenceType", e);
}
}
@Test(timeout = 4000)
public void test253() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectWriter objectWriter0 = objectMapper0.writerWithDefaultPrettyPrinter();
assertNotNull(objectWriter0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectWriter0.hasPrefetchedSerializer());
Class<DoubleNode> class0 = DoubleNode.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
JsonNode jsonNode0 = objectReader1.createArrayNode();
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isFloat());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isInt());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertFalse(jsonNode0.isShort());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertTrue(jsonNode0.isArray());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertTrue(jsonNode0.isEmpty());
assertNotSame(objectReader1, objectReader0);
Enumeration<SequenceInputStream> enumeration0 = (Enumeration<SequenceInputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false, false, false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
MappingIterator<CollectionType> mappingIterator0 = objectReader1.readValues((InputStream) sequenceInputStream0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[0];
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator("pJ1");
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("pJ1", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("pJ1", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonParser_Feature0);
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("pJ1", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("pJ1", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("pJ1", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_TARGET;
JsonFactory jsonFactory3 = jsonFactory2.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory3);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("pJ1", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("pJ1", jsonFactory1.getRootValueSeparator());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(30, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("pJ1", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(30, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals("pJ1", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory3.createParser((InputStream) sequenceInputStream0);
assertNotNull(uTF8StreamJsonParser0);
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("pJ1", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("pJ1", jsonFactory1.getRootValueSeparator());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(30, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("pJ1", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(30, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals("pJ1", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
ValueInstantiators.Base valueInstantiators_Base0 = new ValueInstantiators.Base();
assertNotNull(valueInstantiators_Base0);
BeanDeserializerFactory beanDeserializerFactory1 = (BeanDeserializerFactory)beanDeserializerFactory0.withValueInstantiators(valueInstantiators_Base0);
assertFalse(beanDeserializerFactory1.equals((Object)beanDeserializerFactory0));
assertNotNull(beanDeserializerFactory1);
assertNotSame(beanDeserializerFactory0, beanDeserializerFactory1);
assertNotSame(beanDeserializerFactory1, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory1);
assertFalse(beanDeserializerFactory0.equals((Object)beanDeserializerFactory1));
assertFalse(beanDeserializerFactory1.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl1 = (DefaultDeserializationContext.Impl)defaultDeserializationContext_Impl0.copy();
assertFalse(beanDeserializerFactory0.equals((Object)beanDeserializerFactory1));
assertFalse(beanDeserializerFactory1.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext_Impl1.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext_Impl1);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext_Impl1.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, beanDeserializerFactory1);
assertNotSame(beanDeserializerFactory1, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext_Impl1);
assertNotSame(defaultDeserializationContext_Impl1, defaultDeserializationContext_Impl0);
JsonDeserializer<DecimalNode> jsonDeserializer0 = (JsonDeserializer<DecimalNode>) mock(JsonDeserializer.class, new ViolatedAssumptionAnswer());
MappingIterator<ObjectIdGenerator<SimpleType>> mappingIterator1 = objectReader1._newIterator((JsonParser) uTF8StreamJsonParser0, (DeserializationContext) defaultDeserializationContext_Impl1, (JsonDeserializer<?>) jsonDeserializer0, true);
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(beanDeserializerFactory0.equals((Object)beanDeserializerFactory1));
assertFalse(beanDeserializerFactory1.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext_Impl1));
assertFalse(defaultDeserializationContext_Impl1.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(mappingIterator1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals("pJ1", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("pJ1", jsonFactory1.getRootValueSeparator());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(30, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("pJ1", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertEquals(30, jsonFactory3.getGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertTrue(jsonFactory3.canParseAsync());
assertEquals("pJ1", jsonFactory3.getRootValueSeparator());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext_Impl1.getDeserializationFeatures());
assertNotSame(objectReader1, objectReader0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(beanDeserializerFactory0, beanDeserializerFactory1);
assertNotSame(beanDeserializerFactory1, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext_Impl1);
assertNotSame(defaultDeserializationContext_Impl1, defaultDeserializationContext_Impl0);
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT;
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
deserializationFeatureArray0[1] = deserializationFeature1;
DeserializationFeature deserializationFeature2 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
deserializationFeatureArray0[2] = deserializationFeature2;
DeserializationFeature deserializationFeature3 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
deserializationFeatureArray0[3] = deserializationFeature3;
DeserializationFeature deserializationFeature4 = DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS;
deserializationFeatureArray0[4] = deserializationFeature4;
DeserializationFeature deserializationFeature5 = DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES;
deserializationFeatureArray0[5] = deserializationFeature5;
DeserializationFeature deserializationFeature6 = DeserializationFeature.EAGER_DESERIALIZER_FETCH;
deserializationFeatureArray0[6] = deserializationFeature6;
ObjectReader objectReader2 = objectReader0.withoutFeatures(deserializationFeatureArray0);
assertEquals(7, deserializationFeatureArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 2440, 1249);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals((-2440), byteArrayInputStream0.available());
// Undeclared exception!
try {
objectReader1.readValue((InputStream) sequenceInputStream0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test254() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader[] objectReaderArray0 = new ObjectReader[6];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(6, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.readValues((InputStream) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test255() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
DeserializationFeature deserializationFeature1 = DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES;
ObjectReader objectReader2 = objectReader1.with(deserializationFeature1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(deserializationFeature0.equals((Object)deserializationFeature1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(deserializationFeature1.equals((Object)deserializationFeature0));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(deserializationFeature0, deserializationFeature1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(deserializationFeature1, deserializationFeature0);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
// Undeclared exception!
try {
objectReader1._detectBindAndClose(byteArray0, (-2388), (-2388));
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test256() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
BaseSettings baseSettings0 = ObjectMapper.DEFAULT_BASE;
assertNotNull(baseSettings0);
assertFalse(baseSettings0.hasExplicitTimeZone());
StdSubtypeResolver stdSubtypeResolver0 = new StdSubtypeResolver();
assertNotNull(stdSubtypeResolver0);
SimpleMixInResolver simpleMixInResolver0 = new SimpleMixInResolver((ClassIntrospector.MixInResolver) null);
assertNotNull(simpleMixInResolver0);
assertEquals(0, simpleMixInResolver0.localSize());
RootNameLookup rootNameLookup0 = new RootNameLookup();
assertNotNull(rootNameLookup0);
ConfigOverrides configOverrides0 = new ConfigOverrides();
assertNotNull(configOverrides0);
assertNull(configOverrides0.getDefaultMergeable());
DeserializationConfig deserializationConfig0 = new DeserializationConfig(baseSettings0, stdSubtypeResolver0, simpleMixInResolver0, rootNameLookup0, configOverrides0);
assertNotNull(deserializationConfig0);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
DeserializationConfig deserializationConfig1 = new DeserializationConfig(deserializationConfig0, simpleMixInResolver0);
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertNotNull(deserializationConfig1);
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig1.getRootName());
assertFalse(deserializationConfig1.useRootWrapping());
assertNull(deserializationConfig1.getDefaultMergeable());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertEquals(0, deserializationConfig1.mixInCount());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertFalse(deserializationConfig1.requiresFullValue());
ObjectReader objectReader1 = objectReader0._with(deserializationConfig1);
assertFalse(deserializationConfig0.equals((Object)deserializationConfig1));
assertFalse(deserializationConfig1.equals((Object)deserializationConfig0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(baseSettings0.hasExplicitTimeZone());
assertEquals(0, simpleMixInResolver0.localSize());
assertNull(configOverrides0.getDefaultMergeable());
assertFalse(deserializationConfig0.useRootWrapping());
assertTrue(deserializationConfig0.canOverrideAccessModifiers());
assertNull(deserializationConfig0.getRootName());
assertTrue(deserializationConfig0.isAnnotationProcessingEnabled());
assertNull(deserializationConfig0.getDefaultMergeable());
assertEquals(237020304, deserializationConfig0.getDeserializationFeatures());
assertFalse(deserializationConfig0.requiresFullValue());
assertFalse(deserializationConfig0.shouldSortPropertiesAlphabetically());
assertEquals(0, deserializationConfig0.mixInCount());
assertNull(deserializationConfig1.getRootName());
assertFalse(deserializationConfig1.useRootWrapping());
assertNull(deserializationConfig1.getDefaultMergeable());
assertEquals(237020304, deserializationConfig1.getDeserializationFeatures());
assertTrue(deserializationConfig1.canOverrideAccessModifiers());
assertEquals(0, deserializationConfig1.mixInCount());
assertTrue(deserializationConfig1.isAnnotationProcessingEnabled());
assertFalse(deserializationConfig1.shouldSortPropertiesAlphabetically());
assertFalse(deserializationConfig1.requiresFullValue());
assertNotSame(objectReader0, objectReader1);
assertNotSame(deserializationConfig0, deserializationConfig1);
assertNotSame(deserializationConfig1, deserializationConfig0);
assertNotSame(objectReader1, objectReader0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
Locale locale0 = Locale.US;
assertNotNull(locale0);
assertEquals("", locale0.getVariant());
assertEquals("US", locale0.getCountry());
assertEquals("eng", locale0.getISO3Language());
assertEquals("en_US", locale0.toString());
assertEquals("USA", locale0.getISO3Country());
assertEquals("en", locale0.getLanguage());
ObjectReader objectReader2 = objectReader0.with(locale0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", locale0.getVariant());
assertEquals("US", locale0.getCountry());
assertEquals("eng", locale0.getISO3Language());
assertEquals("en_US", locale0.toString());
assertEquals("USA", locale0.getISO3Country());
assertEquals("en", locale0.getLanguage());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
ObjectReader objectReader3 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
try {
objectReader3.readValues((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test257() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.useStaticType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readTree((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test258() throws Throwable {
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)0;
boolean boolean1 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean1);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(2, byteArray0.length);
assertTrue(boolean1 == boolean0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
Class<NullNode> class0 = NullNode.class;
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, false);
assertNotNull(jsonFactory1);
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class0, (Object) class0);
assertNotNull(injectableValues_Std1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std1);
assertNotNull(objectReader0);
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
IOContext iOContext0 = new IOContext(bufferRecycler0, objectMapper0, false);
assertNotNull(iOContext0);
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayBuilder0.size());
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-1), objectMapper0, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, (byte)0, false);
assertNotNull(uTF8JsonGenerator0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayBuilder0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-1), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
FormatSchema formatSchema0 = uTF8JsonGenerator0.getSchema();
assertNull(formatSchema0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayBuilder0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-1), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertSame(jsonFactory0, jsonFactory1);
ObjectReader objectReader2 = objectReader1.with((FormatSchema) null);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertSame(objectReader2, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(injectableValues_Std0, injectableValues_Std1);
assertSame(injectableValues_Std1, injectableValues_Std0);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
PipedReader pipedReader0 = new PipedReader(56319);
assertNotNull(pipedReader0);
try {
objectReader0.readValue((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test259() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-17);
byteArray0[1] = (byte) (-8);
byteArray0[2] = (byte) (-8);
Vector<ObjectReader> vector0 = new Vector<ObjectReader>();
assertNotNull(vector0);
assertFalse(vector0.contains(objectReader0));
assertTrue(vector0.isEmpty());
assertEquals(10, vector0.capacity());
assertEquals("[]", vector0.toString());
assertEquals(0, vector0.size());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonParser_Feature0, false);
assertNotNull(jsonFactory1);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
Class<MissingNode> class0 = MissingNode.class;
ObjectReader objectReader1 = objectMapper1.readerFor(class0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
JsonNode jsonNode0 = objectReader1.createArrayNode();
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(jsonNode0);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertEquals("", jsonNode0.asText());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isShort());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertFalse(jsonNode0.isBigInteger());
assertTrue(jsonNode0.isArray());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(0, jsonNode0.size());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isFloat());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.forType(class0);
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(1, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectReader2, objectReader0);
assertSame(objectReader2, objectReader1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
assertSame(objectReader1, objectReader2);
try {
MockURL.URL("JSON", "JSON", "Maximum Java array size (2GB) exceeded by `ByteArrayBuilder`");
fail("Expecting exception: MalformedURLException");
} catch(MalformedURLException e) {
//
// unknown protocol: json
//
verifyException("java.net.URL", e);
}
}
@Test(timeout = 4000)
public void test260() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) null);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
// Undeclared exception!
try {
objectReader0.readTree(byteArray0, 209, 209);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 209
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test261() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
JsonFactory jsonFactory1 = jsonFactory0.copy();
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader0 = objectMapper1.reader();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper1, objectMapper0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)91;
byte byte0 = (byte)112;
byteArray0[1] = (byte)112;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)63;
byteArray0[4] = (byte)86;
byteArray0[5] = (byte)1;
byteArray0[6] = (byte)112;
byteArray0[7] = (byte) (-122);
byte byte1 = (byte) (-79);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
DeserializationConfig deserializationConfig0 = defaultDeserializationContext_Impl0.getConfig();
assertNull(deserializationConfig0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
// Undeclared exception!
try {
objectReader0._with((DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test262() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
try {
objectReader0.readValues((InputStream) byteArrayInputStream0);
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: (ByteArrayInputStream); line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test263() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isJavaLangObject());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
ObjectWriter objectWriter0 = objectMapper0.writer((PrettyPrinter) null);
assertNotNull(objectWriter0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(objectWriter0.hasPrefetchedSerializer());
JsonNode jsonNode0 = objectReader0.readTree("");
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(jsonNode0.isBigInteger());
assertTrue(jsonNode0.isEmpty());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isShort());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isArray());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
Class<CollectionType> class1 = CollectionType.class;
SimpleType simpleType1 = SimpleType.constructUnsafe(class1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.hasHandlers());
assertTrue(simpleType1.isFinal());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isContainerType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isInterface());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isArrayType());
assertNotSame(simpleType1, simpleType0);
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test264() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
int int0 = byteArrayInputStream0.read(byteArray0);
assertEquals(1, int0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertEquals(0, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
Class<BinaryNode> class0 = BinaryNode.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNode jsonNode0 = objectReader0.createArrayNode();
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isEmpty());
assertTrue(jsonNode0.isArray());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigDecimal());
MappingIterator<CollectionType> mappingIterator0 = objectReader0.readValues((InputStream) byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, byteArrayInputStream0.available());
ByteArrayInputStream byteArrayInputStream1 = new ByteArrayInputStream(byteArray0, 1249, 1249);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArrayInputStream1.equals((Object)byteArrayInputStream0));
assertNotNull(byteArrayInputStream1);
assertEquals((-1248), byteArrayInputStream1.available());
// Undeclared exception!
try {
objectReader0.readValue((InputStream) byteArrayInputStream0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test265() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
// Undeclared exception!
try {
objectReader1._bindAndClose((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test266() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte byte0 = (byte) (-8);
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-17);
byteArray0[1] = (byte) (-8);
byteArray0[2] = (byte) (-8);
Vector<ObjectReader> vector0 = new Vector<ObjectReader>();
assertNotNull(vector0);
assertFalse(vector0.contains(objectReader0));
assertEquals("[]", vector0.toString());
assertEquals(10, vector0.capacity());
assertEquals(0, vector0.size());
assertTrue(vector0.isEmpty());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(vector0);
assertNotNull(dataFormatReaders0);
assertFalse(vector0.contains(objectReader0));
assertEquals("[]", vector0.toString());
assertEquals(10, vector0.capacity());
assertEquals(0, vector0.size());
assertTrue(vector0.isEmpty());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders0.findFormat(byteArray0);
assertArrayEquals(new byte[] {(byte) (-17), (byte) (-8), (byte) (-8), (byte)0}, byteArray0);
assertEquals(4, byteArray0.length);
assertNotNull(dataFormatReaders_Match0);
assertFalse(vector0.contains(objectReader0));
assertEquals("[]", vector0.toString());
assertEquals(10, vector0.capacity());
assertEquals(0, vector0.size());
assertTrue(vector0.isEmpty());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
// Undeclared exception!
try {
objectReader0._detectBindAndReadValues(dataFormatReaders_Match0, false);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test267() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ObjectNode> class0 = ObjectNode.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.useStaticType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isJavaLangObject());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-8);
ConcurrentHashMap<String, Object> concurrentHashMap0 = new ConcurrentHashMap<String, Object>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(concurrentHashMap0);
assertNotNull(injectableValues_Std0);
assertTrue(concurrentHashMap0.isEmpty());
ObjectMapper objectMapper1 = objectMapper0.setInjectableValues(injectableValues_Std0);
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertEquals(0, objectMapper1.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
ObjectReader objectReader1 = objectReader0.without(deserializationFeature0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
Locale locale0 = new Locale("");
assertNotNull(locale0);
assertEquals("", locale0.getISO3Country());
assertEquals("", locale0.toString());
assertEquals("", locale0.getLanguage());
assertEquals("", locale0.getCountry());
assertEquals("", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
ObjectReader objectReader2 = objectReader0.with(locale0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("", locale0.getISO3Country());
assertEquals("", locale0.toString());
assertEquals("", locale0.getLanguage());
assertEquals("", locale0.getCountry());
assertEquals("", locale0.getISO3Language());
assertEquals("", locale0.getVariant());
assertSame(objectMapper0, objectMapper1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
}
@Test(timeout = 4000)
public void test268() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ObjectNode> class0 = ObjectNode.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasValueHandler());
byte byte0 = (byte) (-8);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-8);
JsonNode jsonNode0 = objectReader0.createArrayNode();
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonNodeType.ARRAY, jsonNode0.getNodeType());
assertEquals(JsonToken.START_ARRAY, jsonNode0.asToken());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isMissingNode());
assertEquals(0, jsonNode0.size());
assertTrue(jsonNode0.isArray());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isObject());
assertTrue(jsonNode0.isEmpty());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isLong());
int int0 = (-24);
// Undeclared exception!
try {
objectReader0.readValues((InputStream) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test269() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
JsonFactory jsonFactory1 = jsonFactory0.setRootValueSeparator((String) null);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertNull(jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertNull(jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8321, jsonFactory0.getParserFeatures());
assertNull(jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertNull(jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8321, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertNull(jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8321, jsonFactory2.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(8321, jsonFactory0.getParserFeatures());
assertNull(jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertNull(jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8321, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertTrue(jsonFactory2.canParseAsync());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertNull(jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(8321, jsonFactory2.getParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader1 = objectMapper0.reader();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader1, objectReader0);
BinaryNode binaryNode0 = BinaryNode.valueOf((byte[]) null);
assertNull(binaryNode0);
Class<ObjectNode> class0 = ObjectNode.class;
// Undeclared exception!
try {
objectReader1.treeToValue((TreeNode) null, class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.node.TreeTraversingParser", e);
}
}
@Test(timeout = 4000)
public void test270() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readValue((Reader) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test271() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper.DefaultTyping objectMapper_DefaultTyping0 = ObjectMapper.DefaultTyping.NON_CONCRETE_AND_ARRAYS;
TypeResolverBuilder<?> typeResolverBuilder0 = objectMapper0._constructDefaultTypeResolverBuilder(objectMapper_DefaultTyping0);
assertNotNull(typeResolverBuilder0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader1 = objectMapper0.reader(jsonNodeFactory0);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
JsonParser.Feature[] jsonParser_FeatureArray0 = new JsonParser.Feature[6];
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_MISSING_VALUES;
jsonParser_FeatureArray0[0] = jsonParser_Feature0;
JsonParser.Feature jsonParser_Feature1 = JsonParser.Feature.ALLOW_TRAILING_COMMA;
jsonParser_FeatureArray0[1] = jsonParser_Feature1;
JsonParser.Feature jsonParser_Feature2 = JsonParser.Feature.ALLOW_YAML_COMMENTS;
jsonParser_FeatureArray0[2] = jsonParser_Feature2;
JsonParser.Feature jsonParser_Feature3 = JsonParser.Feature.ALLOW_COMMENTS;
jsonParser_FeatureArray0[3] = jsonParser_Feature3;
JsonParser.Feature jsonParser_Feature4 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
jsonParser_FeatureArray0[4] = jsonParser_Feature4;
JsonParser.Feature jsonParser_Feature5 = JsonParser.Feature.ALLOW_SINGLE_QUOTES;
jsonParser_FeatureArray0[5] = jsonParser_Feature5;
ObjectReader objectReader2 = objectReader0.withoutFeatures(jsonParser_FeatureArray0);
assertEquals(6, jsonParser_FeatureArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
try {
objectReader1.readValue((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test272() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ObjectNode> class0 = ObjectNode.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
byte byte0 = (byte) (-8);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-8);
try {
objectReader0.readTree(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '\u00F8': was expecting ('true', 'false' or 'null')
// at [Source: (byte[])\"\uFFFD\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test273() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonFactory2);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[3] = objectReader0;
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isPrimitive());
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
ObjectNode objectNode0 = (ObjectNode)dOMSerializer0.getSchema((SerializerProvider) defaultSerializerProvider_Impl0, (Type) class0);
assertNotNull(objectNode0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
TreeTraversingParser treeTraversingParser0 = (TreeTraversingParser)objectReader0.treeAsTokens(objectNode0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(treeTraversingParser0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(0, treeTraversingParser0.getTextOffset());
assertFalse(treeTraversingParser0.isExpectedStartArrayToken());
assertFalse(treeTraversingParser0.hasTextCharacters());
assertFalse(treeTraversingParser0.isExpectedStartObjectToken());
assertFalse(treeTraversingParser0.canReadObjectId());
assertFalse(treeTraversingParser0.hasCurrentToken());
assertFalse(treeTraversingParser0.canParseAsync());
assertFalse(treeTraversingParser0.isClosed());
assertEquals(0, treeTraversingParser0.currentTokenId());
assertFalse(treeTraversingParser0.canReadTypeId());
assertFalse(treeTraversingParser0.requiresCustomCodec());
assertEquals(0, treeTraversingParser0.getCurrentTokenId());
assertEquals(0, treeTraversingParser0.getFormatFeatures());
assertNull(treeTraversingParser0.getLastClearedToken());
assertEquals(0, treeTraversingParser0.getFeatureMask());
assertNull(treeTraversingParser0.getCurrentToken());
assertNull(treeTraversingParser0.currentToken());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
ObjectNode objectNode1 = (ObjectNode)objectReader0._bindAndCloseAsTree(treeTraversingParser0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertTrue(objectNode1.equals((Object)objectNode0));
assertNotNull(objectNode1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(0, treeTraversingParser0.getTextOffset());
assertFalse(treeTraversingParser0.isExpectedStartArrayToken());
assertFalse(treeTraversingParser0.hasTextCharacters());
assertFalse(treeTraversingParser0.isExpectedStartObjectToken());
assertFalse(treeTraversingParser0.canReadObjectId());
assertFalse(treeTraversingParser0.hasCurrentToken());
assertFalse(treeTraversingParser0.canParseAsync());
assertEquals(0, treeTraversingParser0.currentTokenId());
assertFalse(treeTraversingParser0.canReadTypeId());
assertFalse(treeTraversingParser0.requiresCustomCodec());
assertEquals(0, treeTraversingParser0.getCurrentTokenId());
assertEquals(0, treeTraversingParser0.getFormatFeatures());
assertNull(treeTraversingParser0.getLastClearedToken());
assertEquals(0, treeTraversingParser0.getFeatureMask());
assertTrue(treeTraversingParser0.isClosed());
assertNull(treeTraversingParser0.getCurrentToken());
assertNull(treeTraversingParser0.currentToken());
assertFalse(objectNode1.isBigInteger());
assertNull(objectNode1.textValue());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isFloat());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isFloatingPointNumber());
assertEquals("", objectNode1.asText());
assertFalse(objectNode1.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isEmpty());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isBigDecimal());
assertEquals(1, objectNode1.size());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(objectNode0, objectNode1);
assertNotSame(objectNode1, objectNode0);
Byte byte0 = new Byte((byte)0);
assertEquals((byte)0, (byte)byte0);
assertNotNull(byte0);
IntNode intNode0 = (IntNode)objectNode0.numberNode(byte0);
assertTrue(objectNode0.equals((Object)objectNode1));
assertNotNull(intNode0);
assertTrue(intNode0.isEmpty());
assertTrue(intNode0.canConvertToLong());
assertEquals(JsonToken.VALUE_NUMBER_INT, intNode0.asToken());
assertNull(intNode0.textValue());
assertFalse(intNode0.isShort());
assertFalse(intNode0.isNaN());
assertFalse(intNode0.isLong());
assertFalse(intNode0.isFloatingPointNumber());
assertFalse(intNode0.isDouble());
assertTrue(intNode0.isIntegralNumber());
assertFalse(intNode0.isObject());
assertFalse(intNode0.isFloat());
assertEquals(JsonParser.NumberType.INT, intNode0.numberType());
assertEquals(0.0F, intNode0.floatValue(), 0.01F);
assertFalse(intNode0.isBigDecimal());
assertTrue(intNode0.canConvertToInt());
assertFalse(intNode0.isArray());
assertFalse(intNode0.isBigInteger());
assertEquals((short)0, intNode0.shortValue());
assertFalse(intNode0.isMissingNode());
assertEquals(0, intNode0.intValue());
assertFalse(intNode0.booleanValue());
assertEquals(JsonNodeType.NUMBER, intNode0.getNodeType());
assertEquals(0L, intNode0.longValue());
assertTrue(intNode0.isInt());
assertEquals(0.0, intNode0.doubleValue(), 0.01);
assertEquals(0, intNode0.size());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertNotSame(objectNode0, objectNode1);
TypeReference<BooleanNode> typeReference0 = (TypeReference<BooleanNode>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn(class0).when(typeReference0).getType();
ObjectReader objectReader1 = objectReader0.withType(typeReference0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader0, objectReader1);
MappingIterator<BuilderBasedDeserializer> mappingIterator0 = objectReader1._bindAndReadValues((JsonParser) treeTraversingParser0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertTrue(objectNode0.equals((Object)objectNode1));
assertNotNull(mappingIterator0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isInt());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isEmpty());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.booleanValue());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isIntegralNumber());
assertEquals(1, objectNode0.size());
assertNull(objectNode0.textValue());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertEquals(0, treeTraversingParser0.getTextOffset());
assertFalse(treeTraversingParser0.isExpectedStartArrayToken());
assertFalse(treeTraversingParser0.hasTextCharacters());
assertFalse(treeTraversingParser0.isExpectedStartObjectToken());
assertFalse(treeTraversingParser0.canReadObjectId());
assertFalse(treeTraversingParser0.hasCurrentToken());
assertFalse(treeTraversingParser0.canParseAsync());
assertEquals(0, treeTraversingParser0.currentTokenId());
assertFalse(treeTraversingParser0.canReadTypeId());
assertFalse(treeTraversingParser0.requiresCustomCodec());
assertEquals(0, treeTraversingParser0.getCurrentTokenId());
assertEquals(0, treeTraversingParser0.getFormatFeatures());
assertNull(treeTraversingParser0.getLastClearedToken());
assertEquals(0, treeTraversingParser0.getFeatureMask());
assertTrue(treeTraversingParser0.isClosed());
assertNull(treeTraversingParser0.getCurrentToken());
assertNull(treeTraversingParser0.currentToken());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectNode0, objectNode1);
// Undeclared exception!
try {
MockURI.create(" for format ");
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Illegal character in path at index 0: for format
//
verifyException("java.net.URI", e);
}
}
@Test(timeout = 4000)
public void test274() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.getFalse();
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.asBoolean());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertEquals("false", booleanNode0.asText());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertEquals(JsonToken.VALUE_FALSE, booleanNode0.asToken());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isLong());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.asBoolean());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertEquals("false", booleanNode0.asText());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertEquals(JsonToken.VALUE_FALSE, booleanNode0.asToken());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isLong());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
DataInputStream dataInputStream1 = new DataInputStream((InputStream) null);
assertFalse(dataInputStream1.equals((Object)dataInputStream0));
assertNotNull(dataInputStream1);
int int0 = byteArrayInputStream0.read(byteArray0);
assertEquals(1, int0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertEquals(0, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectMapper2);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper2.mixInCount());
ConcurrentHashMap<String, Object> concurrentHashMap0 = new ConcurrentHashMap<String, Object>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
InjectableValues.Std injectableValues_Std1 = new InjectableValues.Std(concurrentHashMap0);
assertFalse(injectableValues_Std1.equals((Object)injectableValues_Std0));
assertNotNull(injectableValues_Std1);
assertTrue(concurrentHashMap0.isEmpty());
ObjectReader objectReader0 = objectMapper2.reader((InjectableValues) injectableValues_Std1);
assertFalse(injectableValues_Std1.equals((Object)injectableValues_Std0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertTrue(concurrentHashMap0.isEmpty());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, objectMapper2.mixInCount());
assertNotSame(injectableValues_Std1, injectableValues_Std0);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
// Undeclared exception!
try {
objectReader0.readValues((DataInput) dataInputStream1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.DataInputStream", e);
}
}
@Test(timeout = 4000)
public void test275() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(objectMapper0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(objectReader0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(64);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(dataFormatReaders0, dataFormatReaders1);
assertSame(dataFormatReaders1, dataFormatReaders0);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
JsonNode jsonNode0 = dOMSerializer0.getSchema((SerializerProvider) defaultSerializerProvider_Impl0, (Type) class0);
assertNotNull(jsonNode0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isEmpty());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isArray());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonParser0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isEmpty());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isArray());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.isClosed());
assertNull(jsonParser0.currentToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
JsonNode jsonNode1 = objectReader0._bindAndCloseAsTree(jsonParser0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertTrue(jsonNode1.equals((Object)jsonNode0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonNode1);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isIntegralNumber());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isEmpty());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isArray());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonParser0.currentTokenId());
assertNull(jsonParser0.currentToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertTrue(jsonParser0.isClosed());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonNode1.isInt());
assertFalse(jsonNode1.isDouble());
assertFalse(jsonNode1.booleanValue());
assertFalse(jsonNode1.isShort());
assertEquals(JsonNodeType.OBJECT, jsonNode1.getNodeType());
assertFalse(jsonNode1.isMissingNode());
assertFalse(jsonNode1.isLong());
assertFalse(jsonNode1.isEmpty());
assertNull(jsonNode1.numberType());
assertTrue(jsonNode1.isObject());
assertFalse(jsonNode1.isBigDecimal());
assertFalse(jsonNode1.isBigInteger());
assertEquals(JsonToken.START_OBJECT, jsonNode1.asToken());
assertEquals(1, jsonNode1.size());
assertFalse(jsonNode1.isFloat());
assertNull(jsonNode1.textValue());
assertFalse(jsonNode1.isIntegralNumber());
assertFalse(jsonNode1.isFloatingPointNumber());
assertEquals("", jsonNode1.asText());
assertFalse(jsonNode1.isArray());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertNotSame(jsonNode0, jsonNode1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonNode1, jsonNode0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
TypeReference<BooleanNode> typeReference0 = (TypeReference<BooleanNode>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn(simpleType0).when(typeReference0).getType();
ObjectReader objectReader1 = objectReader0.withType(typeReference0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader0, objectReader1);
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test276() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte byte0 = (byte) (-49);
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory0.copy();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertNotNull(objectMapper2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper2.mixInCount());
ObjectMapper objectMapper3 = new ObjectMapper(objectMapper1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper3.equals((Object)objectMapper0));
assertFalse(objectMapper3.equals((Object)objectMapper2));
assertFalse(objectMapper3.equals((Object)objectMapper1));
assertNotNull(objectMapper3);
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper3.mixInCount());
ObjectReader objectReader0 = objectMapper3.reader();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper1.equals((Object)objectMapper3));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper3.equals((Object)objectMapper0));
assertFalse(objectMapper3.equals((Object)objectMapper2));
assertFalse(objectMapper3.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertEquals(0, objectMapper1.mixInCount());
assertEquals(0, objectMapper3.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper1, objectMapper3);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper3, objectMapper0);
assertNotSame(objectMapper3, objectMapper2);
assertNotSame(objectMapper3, objectMapper1);
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory2.createParser((char[]) null, (int) (byte) (-49), (int) (byte) (-49));
assertFalse(objectMapper0.equals((Object)objectMapper3));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNotSame(objectMapper0, objectMapper3);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JsonParser jsonParser0 = defaultDeserializationContext_Impl0.getParser();
assertNull(jsonParser0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
JsonParserSequence jsonParserSequence0 = JsonParserSequence.createFlattened(true, (JsonParser) readerBasedJsonParser0, (JsonParser) null);
assertFalse(objectMapper0.equals((Object)objectMapper3));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonParserSequence0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, jsonParserSequence0.containedParsersCount());
assertFalse(jsonParserSequence0.canParseAsync());
assertFalse(jsonParserSequence0.canReadObjectId());
assertFalse(jsonParserSequence0.canReadTypeId());
assertFalse(jsonParserSequence0.requiresCustomCodec());
assertEquals(8193, jsonParserSequence0.getFeatureMask());
assertEquals(0, jsonParserSequence0.getFormatFeatures());
assertNotSame(objectMapper0, objectMapper3);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
JsonParserSequence jsonParserSequence1 = (JsonParserSequence)jsonParserSequence0.skipChildren();
assertFalse(objectMapper0.equals((Object)objectMapper3));
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonParserSequence1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isNaN());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(2, jsonParserSequence0.containedParsersCount());
assertFalse(jsonParserSequence0.canParseAsync());
assertFalse(jsonParserSequence0.canReadObjectId());
assertFalse(jsonParserSequence0.canReadTypeId());
assertFalse(jsonParserSequence0.requiresCustomCodec());
assertEquals(8193, jsonParserSequence0.getFeatureMask());
assertEquals(0, jsonParserSequence0.getFormatFeatures());
assertFalse(jsonParserSequence1.canReadObjectId());
assertFalse(jsonParserSequence1.canReadTypeId());
assertEquals(0, jsonParserSequence1.getFormatFeatures());
assertFalse(jsonParserSequence1.canParseAsync());
assertEquals(8193, jsonParserSequence1.getFeatureMask());
assertFalse(jsonParserSequence1.requiresCustomCodec());
assertEquals(2, jsonParserSequence1.containedParsersCount());
assertNotSame(objectMapper0, objectMapper3);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonParserSequence0, jsonParserSequence1);
assertSame(jsonParserSequence1, jsonParserSequence0);
Class<BeanDeserializer> class0 = BeanDeserializer.class;
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) jsonParserSequence1, class0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.util.JsonParserSequence", e);
}
}
@Test(timeout = 4000)
public void test277() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isInterface());
assertTrue(simpleType0.isJavaLangObject());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
BinaryNode binaryNode0 = BinaryNode.valueOf((byte[]) null);
assertNull(binaryNode0);
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer(simpleType0);
assertNotNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isInterface());
assertTrue(simpleType0.isJavaLangObject());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(AccessPattern.DYNAMIC, jsonDeserializer0.getEmptyAccessPattern());
assertEquals(AccessPattern.CONSTANT, jsonDeserializer0.getNullAccessPattern());
assertFalse(jsonDeserializer0.isCachable());
// Undeclared exception!
try {
objectReader0._detectBindAndClose((byte[]) null, (byte)97, (-2032));
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test278() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.hasValueHandler());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) simpleType0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.hasValueHandler());
assertEquals(0, simpleType0.containedTypeCount());
assertTrue(simpleType0.isJavaLangObject());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
// Undeclared exception!
try {
objectReader0.readTree((byte[]) null, (int) (byte)0, 1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test279() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonFactory2);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectMapper0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectReader0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isPrimitive());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(64);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(dataFormatReaders0, dataFormatReaders1);
assertSame(dataFormatReaders1, dataFormatReaders0);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
JsonNode jsonNode0 = dOMSerializer0.getSchema((SerializerProvider) defaultSerializerProvider_Impl0, (Type) class0);
assertNotNull(jsonNode0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isIntegralNumber());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertNull(jsonNode0.numberType());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonParser0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isIntegralNumber());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertNull(jsonNode0.numberType());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertNull(jsonParser0.currentToken());
assertEquals(0, jsonParser0.currentTokenId());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isClosed());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
JsonNode jsonNode1 = objectReader0._bindAndCloseAsTree(jsonParser0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertTrue(jsonNode1.equals((Object)jsonNode0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonNode1);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isIntegralNumber());
assertTrue(jsonNode0.isObject());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertEquals(1, jsonNode0.size());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isDouble());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isFloat());
assertNull(jsonNode0.numberType());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.hasCurrentToken());
assertNull(jsonParser0.currentToken());
assertEquals(0, jsonParser0.currentTokenId());
assertTrue(jsonParser0.isClosed());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonNode1.isMissingNode());
assertFalse(jsonNode1.isLong());
assertEquals(JsonNodeType.OBJECT, jsonNode1.getNodeType());
assertFalse(jsonNode1.isShort());
assertFalse(jsonNode1.isInt());
assertFalse(jsonNode1.isFloatingPointNumber());
assertFalse(jsonNode1.isDouble());
assertFalse(jsonNode1.isArray());
assertEquals("", jsonNode1.asText());
assertFalse(jsonNode1.isBigInteger());
assertNull(jsonNode1.textValue());
assertFalse(jsonNode1.isBigDecimal());
assertFalse(jsonNode1.isEmpty());
assertEquals(1, jsonNode1.size());
assertFalse(jsonNode1.isIntegralNumber());
assertFalse(jsonNode1.booleanValue());
assertTrue(jsonNode1.isObject());
assertFalse(jsonNode1.isFloat());
assertNull(jsonNode1.numberType());
assertEquals(JsonToken.START_OBJECT, jsonNode1.asToken());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.usesObjectId());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertNotSame(jsonNode0, jsonNode1);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonNode1, jsonNode0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
// Undeclared exception!
try {
MockURI.create(" for format ");
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Illegal character in path at index 0: for format
//
verifyException("java.net.URI", e);
}
}
@Test(timeout = 4000)
public void test280() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonFactory2);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectMapper0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(objectReader0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.useStaticType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isArrayType());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(64);
assertEquals(10, objectReaderArray0.length);
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertSame(dataFormatReaders0, dataFormatReaders1);
assertSame(dataFormatReaders1, dataFormatReaders0);
DOMSerializer dOMSerializer0 = new DOMSerializer();
assertNotNull(dOMSerializer0);
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
JsonNode jsonNode0 = dOMSerializer0.getSchema((SerializerProvider) defaultSerializerProvider_Impl0, (Type) class0);
assertNotNull(jsonNode0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertEquals(1, jsonNode0.size());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonParser0);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertEquals(1, jsonNode0.size());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonParser0.canReadTypeId());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.requiresCustomCodec());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.canReadObjectId());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
JsonNode jsonNode1 = objectReader0._bindAndCloseAsTree(jsonParser0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertTrue(jsonNode1.equals((Object)jsonNode0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertNotNull(jsonNode1);
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isBigInteger());
assertEquals(JsonToken.START_OBJECT, jsonNode0.asToken());
assertFalse(jsonNode0.booleanValue());
assertTrue(jsonNode0.isObject());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertEquals(1, jsonNode0.size());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isLong());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isFloat());
assertEquals(JsonNodeType.OBJECT, jsonNode0.getNodeType());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isDouble());
assertEquals("", jsonNode0.asText());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonParser0.canReadTypeId());
assertEquals(0, jsonParser0.getFormatFeatures());
assertFalse(jsonParser0.requiresCustomCodec());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertTrue(jsonParser0.isClosed());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.canReadObjectId());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonNode1.isEmpty());
assertFalse(jsonNode1.isArray());
assertNull(jsonNode1.numberType());
assertFalse(jsonNode1.booleanValue());
assertTrue(jsonNode1.isObject());
assertFalse(jsonNode1.isInt());
assertFalse(jsonNode1.isIntegralNumber());
assertFalse(jsonNode1.isBigDecimal());
assertFalse(jsonNode1.isMissingNode());
assertFalse(jsonNode1.isBigInteger());
assertFalse(jsonNode1.isShort());
assertEquals(1, jsonNode1.size());
assertNull(jsonNode1.textValue());
assertEquals("", jsonNode1.asText());
assertEquals(JsonNodeType.OBJECT, jsonNode1.getNodeType());
assertFalse(jsonNode1.isFloatingPointNumber());
assertFalse(jsonNode1.isDouble());
assertEquals(JsonToken.START_OBJECT, jsonNode1.asToken());
assertFalse(jsonNode1.isFloat());
assertFalse(jsonNode1.isLong());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertFalse(dOMSerializer0.isUnwrappingSerializer());
assertFalse(dOMSerializer0.usesObjectId());
assertNotSame(jsonNode0, jsonNode1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonNode1, jsonNode0);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory1);
TypeReference<BooleanNode> typeReference0 = (TypeReference<BooleanNode>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.withType(typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test281() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[3];
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT;
deserializationFeatureArray0[1] = deserializationFeature1;
DeserializationFeature deserializationFeature2 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
deserializationFeatureArray0[2] = deserializationFeature2;
ObjectReader objectReader1 = objectReader0.withFeatures(deserializationFeatureArray0);
assertEquals(3, deserializationFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withHandler(deserializationProblemHandler0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader3 = objectReader0.with(jsonNodeFactory0);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
DeserializationFeature deserializationFeature3 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader4 = objectReader2.without(deserializationFeature3);
assertFalse(deserializationFeature3.equals((Object)deserializationFeature2));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature0));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature1));
assertFalse(objectReader4.equals((Object)objectReader2));
assertFalse(objectReader4.equals((Object)objectReader0));
assertFalse(objectReader4.equals((Object)objectReader1));
assertFalse(objectReader4.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader2.equals((Object)objectReader3));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader4);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(deserializationFeature3, deserializationFeature2);
assertNotSame(deserializationFeature3, deserializationFeature0);
assertNotSame(deserializationFeature3, deserializationFeature1);
assertNotSame(objectReader4, objectReader2);
assertNotSame(objectReader4, objectReader0);
assertNotSame(objectReader4, objectReader1);
assertNotSame(objectReader4, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader4);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader2, objectReader4);
assertNotSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)125;
byteArray0[1] = (byte)7;
byteArray0[2] = (byte)87;
byteArray0[3] = (byte)97;
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)118;
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray0);
assertArrayEquals(new byte[] {(byte)125, (byte)7, (byte)87, (byte)97, (byte)1, (byte)118}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(binaryNode0);
assertFalse(binaryNode0.isBigDecimal());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isShort());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isArray());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.booleanValue());
assertFalse(binaryNode0.isIntegralNumber());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isLong());
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer((JavaType) null);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader4));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader3));
assertNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader4);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
TypeReference<MapLikeType> typeReference0 = (TypeReference<MapLikeType>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader1.withType(typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test282() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonFactory jsonFactory1 = jsonFactory0.copy();
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertNotSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_TRAILING_COMMA;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonParser_Feature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(objectMapper0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_LONG_FOR_INTS;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory0.equals((Object)jsonFactory1));
assertFalse(jsonFactory1.equals((Object)jsonFactory0));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(objectReader0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(jsonFactory0, jsonFactory2);
assertNotSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
// Undeclared exception!
try {
objectReader0.withType((TypeReference<?>) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test283() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
int int0 = byteArrayInputStream0.read(byteArray0);
assertEquals(1, int0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertEquals(0, byteArrayInputStream0.available());
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
assertNotNull(injectableValues_Std0);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory1);
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertNotNull(objectMapper2);
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper2.mixInCount());
Class<ArrayNode> class0 = ArrayNode.class;
Class<BinaryNode> class1 = BinaryNode.class;
Stack<JavaType> stack0 = new Stack<JavaType>();
assertNotNull(stack0);
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
TypeBindings typeBindings0 = TypeBindings.create((Class<?>) class1, (List<JavaType>) stack0);
assertNotNull(typeBindings0);
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, typeBindings0);
assertNotNull(resolvedRecursiveType0);
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isEnumType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
JavaType javaType0 = resolvedRecursiveType0.withTypeHandler(class1);
assertNotNull(javaType0);
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isEnumType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(javaType0.isArrayType());
assertTrue(javaType0.hasContentType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isAbstract());
assertEquals(0, javaType0.containedTypeCount());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isJavaLangObject());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(resolvedRecursiveType0, javaType0);
assertSame(javaType0, resolvedRecursiveType0);
ObjectReader objectReader0 = objectMapper2.readerFor(javaType0);
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertNotNull(objectReader0);
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isEnumType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(javaType0.isArrayType());
assertTrue(javaType0.hasContentType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isAbstract());
assertEquals(0, javaType0.containedTypeCount());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isJavaLangObject());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper2.mixInCount());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(resolvedRecursiveType0, javaType0);
assertSame(javaType0, resolvedRecursiveType0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
byte[] byteArray1 = new byte[4];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte) (-49);
byteArray1[1] = (byte)1;
byteArray1[2] = (byte) (-49);
byteArray1[3] = (byte) (-49);
JsonNode jsonNode0 = objectReader0.readTree(byteArray1, 1, (-956));
assertArrayEquals(new byte[] {(byte) (-49), (byte)1, (byte) (-49), (byte) (-49)}, byteArray1);
assertEquals(4, byteArray1.length);
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(jsonNode0);
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isEnumType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(javaType0.isArrayType());
assertTrue(javaType0.hasContentType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isAbstract());
assertEquals(0, javaType0.containedTypeCount());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isJavaLangObject());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertFalse(jsonNode0.booleanValue());
assertEquals(0, jsonNode0.size());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isLong());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.isArray());
assertTrue(jsonNode0.isEmpty());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper2.mixInCount());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
assertSame(resolvedRecursiveType0, javaType0);
assertSame(javaType0, resolvedRecursiveType0);
assertNotSame(byteArray1, byteArray0);
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertArrayEquals(new byte[] {(byte) (-49), (byte)1, (byte) (-49), (byte) (-49)}, byteArray1);
assertEquals(4, byteArray1.length);
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(jsonParser0);
assertTrue(resolvedRecursiveType0.isConcrete());
assertFalse(resolvedRecursiveType0.isCollectionLikeType());
assertFalse(resolvedRecursiveType0.isContainerType());
assertFalse(resolvedRecursiveType0.isFinal());
assertFalse(resolvedRecursiveType0.hasHandlers());
assertTrue(resolvedRecursiveType0.hasContentType());
assertFalse(resolvedRecursiveType0.isAbstract());
assertFalse(resolvedRecursiveType0.hasValueHandler());
assertFalse(resolvedRecursiveType0.isJavaLangObject());
assertEquals(0, resolvedRecursiveType0.containedTypeCount());
assertFalse(resolvedRecursiveType0.useStaticType());
assertFalse(resolvedRecursiveType0.isPrimitive());
assertFalse(resolvedRecursiveType0.isArrayType());
assertFalse(resolvedRecursiveType0.isEnumType());
assertFalse(resolvedRecursiveType0.isMapLikeType());
assertFalse(resolvedRecursiveType0.isInterface());
assertFalse(javaType0.isArrayType());
assertTrue(javaType0.hasContentType());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.hasHandlers());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.isPrimitive());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isAbstract());
assertEquals(0, javaType0.containedTypeCount());
assertTrue(javaType0.isConcrete());
assertFalse(javaType0.isJavaLangObject());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isShort());
assertFalse(jsonNode0.isInt());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.isObject());
assertFalse(jsonNode0.booleanValue());
assertEquals(0, jsonNode0.size());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isLong());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isBigInteger());
assertNull(jsonNode0.textValue());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertFalse(jsonNode0.isArray());
assertTrue(jsonNode0.isEmpty());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonParser0.canReadTypeId());
assertEquals(0, jsonParser0.getFeatureMask());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertEquals(0, jsonParser0.getTextOffset());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.getLastClearedToken());
assertFalse(jsonParser0.hasCurrentToken());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.canParseAsync());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, objectMapper2.mixInCount());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper2, objectMapper0);
assertNotSame(objectMapper2, objectMapper1);
assertSame(resolvedRecursiveType0, javaType0);
assertSame(javaType0, resolvedRecursiveType0);
assertNotSame(byteArray1, byteArray0);
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ContextAttributes contextAttributes1 = contextAttributes0.withPerCallAttribute(byteArrayInputStream0, injectableValues_Std0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertNotNull(contextAttributes1);
assertEquals(0, byteArrayInputStream0.available());
assertNotSame(byteArray0, byteArray1);
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes0);
ConcurrentHashMap<BinaryNode, MapperFeature> concurrentHashMap0 = new ConcurrentHashMap<BinaryNode, MapperFeature>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ContextAttributes contextAttributes2 = contextAttributes1.withSharedAttributes(concurrentHashMap0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(contextAttributes2.equals((Object)contextAttributes1));
assertFalse(contextAttributes2.equals((Object)contextAttributes0));
assertNotNull(contextAttributes2);
assertEquals(0, byteArrayInputStream0.available());
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(byteArray0, byteArray1);
assertNotSame(contextAttributes0, contextAttributes2);
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes2);
assertNotSame(contextAttributes1, contextAttributes0);
assertNotSame(contextAttributes2, contextAttributes1);
assertNotSame(contextAttributes2, contextAttributes0);
ContextAttributes contextAttributes3 = contextAttributes2.withoutSharedAttribute(typeBindings0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(contextAttributes0.equals((Object)contextAttributes2));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes2));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(contextAttributes2.equals((Object)contextAttributes1));
assertFalse(contextAttributes2.equals((Object)contextAttributes0));
assertFalse(contextAttributes3.equals((Object)contextAttributes1));
assertFalse(contextAttributes3.equals((Object)contextAttributes0));
assertNotNull(contextAttributes3);
assertEquals(0, byteArrayInputStream0.available());
assertTrue(concurrentHashMap0.isEmpty());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertNotSame(byteArray0, byteArray1);
assertNotSame(contextAttributes0, contextAttributes3);
assertNotSame(contextAttributes0, contextAttributes2);
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes2);
assertNotSame(contextAttributes1, contextAttributes3);
assertNotSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes2, contextAttributes3);
assertNotSame(contextAttributes2, contextAttributes1);
assertNotSame(contextAttributes2, contextAttributes0);
assertNotSame(contextAttributes3, contextAttributes1);
assertNotSame(contextAttributes3, contextAttributes0);
assertSame(contextAttributes3, contextAttributes2);
ObjectReader objectReader1 = objectMapper1.reader(contextAttributes3);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(contextAttributes0.equals((Object)contextAttributes3));
assertFalse(contextAttributes0.equals((Object)contextAttributes2));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes2));
assertFalse(contextAttributes1.equals((Object)contextAttributes3));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(contextAttributes2.equals((Object)contextAttributes1));
assertFalse(contextAttributes2.equals((Object)contextAttributes0));
assertFalse(contextAttributes3.equals((Object)contextAttributes1));
assertFalse(contextAttributes3.equals((Object)contextAttributes0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, byteArrayInputStream0.available());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(15, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(15, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(stack0.empty());
assertEquals(0, stack0.size());
assertEquals("[]", stack0.toString());
assertTrue(stack0.isEmpty());
assertEquals(10, stack0.capacity());
assertTrue(typeBindings0.isEmpty());
assertEquals(0, typeBindings0.size());
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(byteArray0, byteArray1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper1, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(contextAttributes0, contextAttributes3);
assertNotSame(contextAttributes0, contextAttributes2);
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes2);
assertNotSame(contextAttributes1, contextAttributes3);
assertNotSame(contextAttributes1, contextAttributes0);
assertSame(contextAttributes2, contextAttributes3);
assertNotSame(contextAttributes2, contextAttributes1);
assertNotSame(contextAttributes2, contextAttributes0);
assertNotSame(contextAttributes3, contextAttributes1);
assertNotSame(contextAttributes3, contextAttributes0);
assertSame(contextAttributes3, contextAttributes2);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1._bindAndCloseAsTree(jsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test284() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
HashSet<String> hashSet0 = new HashSet<String>();
assertNotNull(hashSet0);
assertTrue(hashSet0.isEmpty());
assertEquals(0, hashSet0.size());
ObjectReader[] objectReaderArray0 = new ObjectReader[8];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[7] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(8, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
MatchStrength matchStrength0 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withOptimalMatch(matchStrength0);
assertEquals(8, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(1);
assertEquals(8, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
DataFormatReaders dataFormatReaders3 = dataFormatReaders2.withType((JavaType) null);
assertEquals(8, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders3);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders3.findFormat(byteArray0, 1, 3687);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertEquals(8, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders3.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders3));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders_Match0);
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders1, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders3);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders1);
assertNotSame(dataFormatReaders3, dataFormatReaders0);
assertNotSame(dataFormatReaders3, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders3);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match0, true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test285() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertTrue(arrayNode0.isArray());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
Short short0 = new Short((short)2175);
assertEquals((short)2175, (short)short0);
assertNotNull(short0);
ShortNode shortNode0 = (ShortNode)arrayNode0.numberNode(short0);
assertNotNull(shortNode0);
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertTrue(arrayNode0.isArray());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(shortNode0.isNaN());
assertFalse(shortNode0.isDouble());
assertTrue(shortNode0.isIntegralNumber());
assertEquals(2175.0, shortNode0.doubleValue(), 0.01);
assertFalse(shortNode0.booleanValue());
assertFalse(shortNode0.isLong());
assertTrue(shortNode0.canConvertToLong());
assertEquals(0, shortNode0.size());
assertTrue(shortNode0.isShort());
assertFalse(shortNode0.isObject());
assertEquals(JsonToken.VALUE_NUMBER_INT, shortNode0.asToken());
assertFalse(shortNode0.isArray());
assertEquals(JsonNodeType.NUMBER, shortNode0.getNodeType());
assertFalse(shortNode0.isBigDecimal());
assertEquals(2175, shortNode0.intValue());
assertNull(shortNode0.textValue());
assertEquals(JsonParser.NumberType.INT, shortNode0.numberType());
assertEquals((short)2175, shortNode0.shortValue());
assertFalse(shortNode0.isFloatingPointNumber());
assertEquals(2175.0F, shortNode0.floatValue(), 0.01F);
assertFalse(shortNode0.isFloat());
assertTrue(shortNode0.canConvertToInt());
assertTrue(shortNode0.isEmpty());
assertFalse(shortNode0.isInt());
assertEquals(2175L, shortNode0.longValue());
assertFalse(shortNode0.isBigInteger());
assertFalse(shortNode0.isMissingNode());
TreeTraversingParser treeTraversingParser0 = (TreeTraversingParser)objectMapper0.treeAsTokens(shortNode0);
assertNotNull(treeTraversingParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertTrue(arrayNode0.isArray());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.booleanValue());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(shortNode0.isNaN());
assertFalse(shortNode0.isDouble());
assertTrue(shortNode0.isIntegralNumber());
assertEquals(2175.0, shortNode0.doubleValue(), 0.01);
assertFalse(shortNode0.booleanValue());
assertFalse(shortNode0.isLong());
assertTrue(shortNode0.canConvertToLong());
assertEquals(0, shortNode0.size());
assertTrue(shortNode0.isShort());
assertFalse(shortNode0.isObject());
assertEquals(JsonToken.VALUE_NUMBER_INT, shortNode0.asToken());
assertFalse(shortNode0.isArray());
assertEquals(JsonNodeType.NUMBER, shortNode0.getNodeType());
assertFalse(shortNode0.isBigDecimal());
assertEquals(2175, shortNode0.intValue());
assertNull(shortNode0.textValue());
assertEquals(JsonParser.NumberType.INT, shortNode0.numberType());
assertEquals((short)2175, shortNode0.shortValue());
assertFalse(shortNode0.isFloatingPointNumber());
assertEquals(2175.0F, shortNode0.floatValue(), 0.01F);
assertFalse(shortNode0.isFloat());
assertTrue(shortNode0.canConvertToInt());
assertTrue(shortNode0.isEmpty());
assertFalse(shortNode0.isInt());
assertEquals(2175L, shortNode0.longValue());
assertFalse(shortNode0.isBigInteger());
assertFalse(shortNode0.isMissingNode());
assertFalse(treeTraversingParser0.canReadTypeId());
assertNull(treeTraversingParser0.currentToken());
assertFalse(treeTraversingParser0.canReadObjectId());
assertEquals(0, treeTraversingParser0.getFeatureMask());
assertEquals(0, treeTraversingParser0.currentTokenId());
assertFalse(treeTraversingParser0.isClosed());
assertFalse(treeTraversingParser0.isExpectedStartObjectToken());
assertFalse(treeTraversingParser0.hasTextCharacters());
assertFalse(treeTraversingParser0.isExpectedStartArrayToken());
assertEquals(0, treeTraversingParser0.getTextOffset());
assertNull(treeTraversingParser0.getLastClearedToken());
assertFalse(treeTraversingParser0.requiresCustomCodec());
assertNull(treeTraversingParser0.getCurrentToken());
assertEquals(0, treeTraversingParser0.getFormatFeatures());
assertEquals(0, treeTraversingParser0.getCurrentTokenId());
assertFalse(treeTraversingParser0.canParseAsync());
assertFalse(treeTraversingParser0.hasCurrentToken());
// Undeclared exception!
try {
objectReader0._bind(treeTraversingParser0, shortNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test286() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
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.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
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);
char[] charArray0 = new char[3];
charArray0[0] = 'w';
charArray0[1] = '/';
charArray0[2] = 'l';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectMapper0, charsToNameCanonicalizer0, charArray0, (byte) (-49), 1257, false);
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
FormatSchema formatSchema0 = readerBasedJsonParser1.getSchema();
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(formatSchema0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setRootValueSeparator("JSON");
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonParser_Feature0);
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory3);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader1 = objectMapper1.reader((FormatSchema) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withoutRootName();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
Class<SimpleObjectIdResolver> class0 = SimpleObjectIdResolver.class;
ObjectReader objectReader3 = objectReader2.forType(class0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
MappingIterator<FilteringParserDelegate> mappingIterator0 = objectReader0.readValues((JsonParser) readerBasedJsonParser1);
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isObject());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigInteger());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isArray());
assertTrue(booleanNode0.isEmpty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
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);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
Class<FilteringParserDelegate> class1 = FilteringParserDelegate.class;
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser1, class1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -49
//
verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
}
}
@Test(timeout = 4000)
public void test287() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isContainerType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
String string0 = "Gf~MvX3x%>6S:3x4#";
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
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, jsonNodeFactory0, true);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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);
PipedWriter pipedWriter0 = new PipedWriter();
assertNotNull(pipedWriter0);
PipedReader pipedReader1 = new PipedReader(pipedWriter0);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(pipedReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[0] = ']';
charArray0[1] = '-';
charArray0[2] = 'W';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 873, pipedReader1, objectMapper0, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(873, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideStdFeatures(0, 3);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(872, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(872, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(pipedReader1, pipedReader0);
ReaderBasedJsonParser readerBasedJsonParser2 = (ReaderBasedJsonParser)objectReader0._considerFilter(readerBasedJsonParser1, false);
assertArrayEquals(new char[] {']', '-', 'W'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(pipedReader1.equals((Object)pipedReader0));
assertNotNull(readerBasedJsonParser2);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(872, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(872, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(872, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isNaN());
assertEquals(0, readerBasedJsonParser2.currentTokenId());
assertNull(readerBasedJsonParser2.currentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.canParseAsync());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
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);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser0, readerBasedJsonParser2);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(readerBasedJsonParser1, readerBasedJsonParser2);
assertSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(pipedReader1, pipedReader0);
TypeReference<CoreXMLDeserializers.Std> typeReference0 = (TypeReference<CoreXMLDeserializers.Std>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) readerBasedJsonParser2, typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test288() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-72);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-72)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-72)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-72)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isLong());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertTrue(booleanNode0.asBoolean());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
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());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.currentToken());
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[] charArray0 = new char[3];
charArray0[1] = '/';
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isLong());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals("", arrayNode0.asText());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals(0, arrayNode0.size());
assertFalse(arrayNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isFloat());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
Short short0 = new Short((byte) (-72));
assertEquals((short) (-72), (short)short0);
assertNotNull(short0);
Short short1 = new Short((short)0);
assertEquals((short)0, (short)short1);
assertFalse(short1.equals((Object)short0));
assertNotNull(short1);
BeanProperty.Bogus beanProperty_Bogus0 = new BeanProperty.Bogus();
assertNotNull(beanProperty_Bogus0);
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(beanProperty_Bogus0.isRequired());
JavaType javaType0 = beanProperty_Bogus0.getType();
assertNotNull(javaType0);
assertEquals("", beanProperty_Bogus0.getName());
assertFalse(beanProperty_Bogus0.isVirtual());
assertFalse(beanProperty_Bogus0.isRequired());
assertFalse(javaType0.isInterface());
assertFalse(javaType0.isFinal());
assertFalse(javaType0.isArrayType());
assertFalse(javaType0.hasHandlers());
assertTrue(javaType0.isConcrete());
assertEquals(0, javaType0.containedTypeCount());
assertFalse(javaType0.isEnumType());
assertFalse(javaType0.isAbstract());
assertTrue(javaType0.isJavaLangObject());
assertFalse(javaType0.useStaticType());
assertFalse(javaType0.isCollectionLikeType());
assertFalse(javaType0.isContainerType());
assertFalse(javaType0.isMapLikeType());
assertFalse(javaType0.hasContentType());
assertFalse(javaType0.hasValueHandler());
assertFalse(javaType0.isPrimitive());
try {
objectReader0.readValue((JsonParser) readerBasedJsonParser0, (ResolvedType) javaType0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'entries': was expecting ('true', 'false' or 'null')
// at [Source: UNKNOWN; line: 1, column: 17]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test289() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader1.readTree((byte[]) null, (-28), (int) (byte)0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test290() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
URL uRL0 = MockURL.getFtpExample();
assertNotNull(uRL0);
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getHost());
assertNull(uRL0.getQuery());
assertEquals("ftp", uRL0.getProtocol());
assertNull(uRL0.getRef());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toExternalForm());
assertEquals((-1), uRL0.getDefaultPort());
assertEquals((-1), uRL0.getPort());
assertNull(uRL0.getUserInfo());
assertEquals("ftp.someFakeButWellFormedURL.org", uRL0.getAuthority());
assertEquals("ftp://ftp.someFakeButWellFormedURL.org/fooExample", uRL0.toString());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(":] -&?A;wu38-");
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader1.withRootName(":] -&?A;wu38-");
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
assertNotNull(jsonpCharacterEscapes0);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
JsonFactory jsonFactory2 = jsonFactory1.configure(jsonParser_Feature0, true);
assertNotNull(jsonFactory2);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
char[] charArray0 = new char[8];
charArray0[0] = '{';
int[] intArray0 = CharacterEscapes.standardAsciiEscapesForJSON();
assertEquals(128, intArray0.length);
assertNotNull(intArray0);
charArray0[1] = '3';
charArray0[2] = '{';
charArray0[3] = '+';
charArray0[5] = '3';
charArray0[6] = '$';
charArray0[7] = '3';
ReaderBasedJsonParser readerBasedJsonParser0 = (ReaderBasedJsonParser)jsonFactory2.createParser(charArray0);
assertArrayEquals(new char[] {'{', '3', '{', '+', '\u0000', '3', '$', '3'}, charArray0);
assertEquals(8, charArray0.length);
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
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.isNaN());
assertEquals(8195, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
MappingIterator<PlaceholderForType> mappingIterator0 = objectReader1._bindAndReadValues((JsonParser) readerBasedJsonParser0);
assertArrayEquals(new char[] {'{', '3', '{', '+', '\u0000', '3', '$', '3'}, charArray0);
assertEquals(8, charArray0.length);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isNaN());
assertEquals(8195, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.currentToken());
assertEquals(1, readerBasedJsonParser0.currentTokenId());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(8195, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(8195, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8195, jsonFactory2.getParserFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader1, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
try {
objectReader2.readTree((JsonParser) readerBasedJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ('3' (code 51)): was expecting double-quote to start field name
// at [Source: (char[])\"{3{+\u00003$3\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test291() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectMapper2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, objectMapper2.mixInCount());
Class<LongNode> class0 = LongNode.class;
ObjectReader objectReader0 = objectMapper2.readerFor(class0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, objectMapper2.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper1, objectMapper2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
PriorityQueue<ObjectReader> priorityQueue0 = new PriorityQueue<ObjectReader>(1);
assertNotNull(priorityQueue0);
assertFalse(priorityQueue0.contains(objectReader0));
assertEquals(0, priorityQueue0.size());
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(priorityQueue0);
assertNotNull(dataFormatReaders0);
assertFalse(priorityQueue0.contains(objectReader0));
assertEquals(0, priorityQueue0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(1);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertFalse(priorityQueue0.contains(objectReader0));
assertEquals(0, priorityQueue0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
MatchStrength matchStrength0 = MatchStrength.NO_MATCH;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders2);
assertFalse(priorityQueue0.contains(objectReader0));
assertEquals(0, priorityQueue0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte)60;
byteArray0[2] = (byte) (-101);
byteArray0[3] = (byte) (-106);
byte byte0 = (byte) (-76);
byteArray0[4] = (byte) (-76);
boolean boolean0 = priorityQueue0.add(objectReader0);
assertTrue(boolean0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper0.equals((Object)objectMapper2));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectMapper1.equals((Object)objectMapper2));
assertFalse(objectMapper2.equals((Object)objectMapper1));
assertFalse(objectMapper2.equals((Object)objectMapper0));
assertTrue(priorityQueue0.contains(objectReader0));
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(1, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(1, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertEquals(0, objectMapper2.mixInCount());
assertEquals(1, priorityQueue0.size());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper0, objectMapper2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectMapper1, objectMapper2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(objectMapper2, objectMapper1);
assertNotSame(objectMapper2, objectMapper0);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders2.findFormat(byteArray0, (-1425), (int) (byte) (-101));
assertArrayEquals(new byte[] {(byte)0, (byte)60, (byte) (-101), (byte) (-106), (byte) (-76)}, byteArray0);
assertEquals(5, byteArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNotNull(dataFormatReaders_Match0);
assertTrue(priorityQueue0.contains(objectReader0));
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(1, priorityQueue0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
JsonParser jsonParser0 = dataFormatReaders_Match0.createParserWithMatch();
assertArrayEquals(new byte[] {(byte)0, (byte)60, (byte) (-101), (byte) (-106), (byte) (-76)}, byteArray0);
assertEquals(5, byteArray0.length);
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders0.equals((Object)dataFormatReaders1));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders2));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders0));
assertFalse(dataFormatReaders2.equals((Object)dataFormatReaders1));
assertNull(jsonParser0);
assertTrue(priorityQueue0.contains(objectReader0));
assertEquals(MatchStrength.INCONCLUSIVE, dataFormatReaders_Match0.getMatchStrength());
assertFalse(dataFormatReaders_Match0.hasMatch());
assertEquals(1, priorityQueue0.size());
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders2);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
assertNotSame(dataFormatReaders1, dataFormatReaders2);
assertNotSame(dataFormatReaders2, dataFormatReaders0);
assertNotSame(dataFormatReaders2, dataFormatReaders1);
// Undeclared exception!
try {
objectReader0._bindAndCloseAsTree((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test292() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isJavaLangObject());
SimpleType simpleType1 = SimpleType.constructUnsafe(class0);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertFalse(simpleType1.hasValueHandler());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isAbstract());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isInterface());
assertNotSame(simpleType1, simpleType0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) simpleType1);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasValueHandler());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isAbstract());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isInterface());
assertNotSame(simpleType1, simpleType0);
JsonNode jsonNode0 = objectReader0.readTree(byteArray0, (int) (byte)0, (int) (byte)0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasValueHandler());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isAbstract());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isInterface());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isObject());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isLong());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertEquals(0, jsonNode0.size());
assertNotSame(simpleType1, simpleType0);
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasValueHandler());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isAbstract());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isInterface());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isFloatingPointNumber());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isShort());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertTrue(jsonNode0.isMissingNode());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isObject());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isArray());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isInt());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isLong());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertEquals(0, jsonNode0.size());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.currentToken());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNotSame(simpleType1, simpleType0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertNotNull(tokenFilter0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
assertTrue(simpleType1.equals((Object)simpleType0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasValueHandler());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isAbstract());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.isArrayType());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.isInterface());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
}
@Test(timeout = 4000)
public void test293() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isInterface());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
Class<String> class1 = String.class;
SimpleType simpleType1 = SimpleType.constructUnsafe(class1);
assertFalse(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isInterface());
assertFalse(simpleType1.isArrayType());
assertTrue(simpleType1.isFinal());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isContainerType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isCollectionLikeType());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.useStaticType());
assertNotSame(simpleType1, simpleType0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
StdKeyDeserializers stdKeyDeserializers0 = new StdKeyDeserializers();
assertNotNull(stdKeyDeserializers0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withAdditionalKeyDeserializers(stdKeyDeserializers0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(defaultDeserializationContext0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, defaultDeserializationContext0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(objectMapper0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) simpleType0);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(simpleType0.equals((Object)simpleType1));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(objectReader0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isInterface());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(simpleType0, simpleType1);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)0;
JsonNode jsonNode0 = objectReader0.readTree(byteArray0, (-4261), (-128));
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, byteArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(simpleType0.equals((Object)simpleType1));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(jsonNode0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isInterface());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isInt());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isShort());
assertTrue(jsonNode0.isMissingNode());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isLong());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isArray());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(simpleType0, simpleType1);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, byteArray0.length);
assertFalse(jsonFactory0.equals((Object)jsonFactory2));
assertFalse(jsonFactory1.equals((Object)jsonFactory2));
assertFalse(jsonFactory2.equals((Object)jsonFactory1));
assertFalse(jsonFactory2.equals((Object)jsonFactory0));
assertFalse(simpleType0.equals((Object)simpleType1));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertNotNull(jsonParser0);
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isInterface());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isArrayType());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isFloat());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isBigDecimal());
assertFalse(jsonNode0.isInt());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isShort());
assertTrue(jsonNode0.isMissingNode());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isLong());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloatingPointNumber());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isArray());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertFalse(jsonParser0.hasTextCharacters());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.canReadObjectId());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canParseAsync());
assertNull(jsonParser0.getLastClearedToken());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.requiresCustomCodec());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.canReadTypeId());
assertNull(jsonParser0.getCurrentToken());
assertNull(jsonParser0.currentToken());
assertSame(jsonFactory0, jsonFactory1);
assertNotSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertNotSame(jsonFactory1, jsonFactory2);
assertNotSame(jsonFactory2, jsonFactory1);
assertNotSame(jsonFactory2, jsonFactory0);
assertNotSame(simpleType0, simpleType1);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
// Undeclared exception!
try {
objectReader0._bindAndCloseAsTree(jsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test294() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isPrimitive());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.hasValueHandler());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
SimpleType simpleType1 = SimpleType.constructUnsafe(class0);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(simpleType1);
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isContainerType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isInterface());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isArrayType());
assertNotSame(simpleType1, simpleType0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
ObjectReader objectReader0 = objectMapper0.readerFor((JavaType) simpleType1);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isContainerType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isInterface());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isArrayType());
assertNotSame(simpleType1, simpleType0);
JsonNode jsonNode0 = objectReader0.readTree(byteArray0, (int) (byte)0, (int) (byte)0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(jsonNode0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isContainerType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isInterface());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isArrayType());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertTrue(jsonNode0.isMissingNode());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloat());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isLong());
assertNotSame(simpleType1, simpleType0);
JsonParser jsonParser0 = objectReader0.treeAsTokens(jsonNode0);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, byteArray0.length);
assertTrue(simpleType1.equals((Object)simpleType0));
assertNotNull(jsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(simpleType1.hasContentType());
assertFalse(simpleType1.isMapLikeType());
assertFalse(simpleType1.useStaticType());
assertFalse(simpleType1.isJavaLangObject());
assertFalse(simpleType1.isPrimitive());
assertFalse(simpleType1.isFinal());
assertFalse(simpleType1.hasHandlers());
assertFalse(simpleType1.isCollectionLikeType());
assertFalse(simpleType1.isContainerType());
assertTrue(simpleType1.isConcrete());
assertFalse(simpleType1.isEnumType());
assertFalse(simpleType1.isAbstract());
assertFalse(simpleType1.isInterface());
assertEquals(0, simpleType1.containedTypeCount());
assertFalse(simpleType1.hasValueHandler());
assertFalse(simpleType1.isArrayType());
assertFalse(jsonNode0.isBigDecimal());
assertTrue(jsonNode0.isEmpty());
assertFalse(jsonNode0.isShort());
assertTrue(jsonNode0.isMissingNode());
assertEquals(JsonNodeType.MISSING, jsonNode0.getNodeType());
assertNull(jsonNode0.textValue());
assertFalse(jsonNode0.isBigInteger());
assertFalse(jsonNode0.isFloatingPointNumber());
assertFalse(jsonNode0.isDouble());
assertFalse(jsonNode0.isInt());
assertEquals("", jsonNode0.asText());
assertFalse(jsonNode0.isArray());
assertEquals(JsonToken.NOT_AVAILABLE, jsonNode0.asToken());
assertFalse(jsonNode0.isObject());
assertNull(jsonNode0.numberType());
assertFalse(jsonNode0.booleanValue());
assertFalse(jsonNode0.isIntegralNumber());
assertFalse(jsonNode0.isFloat());
assertEquals(0, jsonNode0.size());
assertFalse(jsonNode0.isLong());
assertEquals(0, jsonParser0.getFeatureMask());
assertFalse(jsonParser0.isExpectedStartObjectToken());
assertFalse(jsonParser0.hasTextCharacters());
assertEquals(0, jsonParser0.getTextOffset());
assertFalse(jsonParser0.canReadObjectId());
assertFalse(jsonParser0.canParseAsync());
assertEquals(0, jsonParser0.currentTokenId());
assertFalse(jsonParser0.isClosed());
assertFalse(jsonParser0.hasCurrentToken());
assertFalse(jsonParser0.canReadTypeId());
assertFalse(jsonParser0.requiresCustomCodec());
assertFalse(jsonParser0.isExpectedStartArrayToken());
assertNull(jsonParser0.getCurrentToken());
assertEquals(0, jsonParser0.getFormatFeatures());
assertEquals(0, jsonParser0.getCurrentTokenId());
assertNull(jsonParser0.getLastClearedToken());
assertNull(jsonParser0.currentToken());
assertNotSame(simpleType1, simpleType0);
// Undeclared exception!
try {
objectReader0._bindAndCloseAsTree(jsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test295() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isInterface());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isPrimitive());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)97;
byteArray0[1] = (byte)118;
byteArray0[2] = (byte)97;
byteArray0[3] = (byte)97;
byteArray0[4] = (byte)118;
byteArray0[5] = (byte)97;
byteArray0[6] = (byte)118;
byteArray0[7] = (byte)1;
byteArray0[8] = (byte)97;
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray0);
assertArrayEquals(new byte[] {(byte)97, (byte)118, (byte)97, (byte)97, (byte)118, (byte)97, (byte)118, (byte)1, (byte)97}, byteArray0);
assertEquals(9, byteArray0.length);
assertNotNull(binaryNode0);
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isLong());
assertFalse(binaryNode0.isIntegralNumber());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.booleanValue());
assertFalse(binaryNode0.isBigDecimal());
assertTrue(binaryNode0.isEmpty());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isMissingNode());
assertFalse(binaryNode0.isBigInteger());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isShort());
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer((JavaType) null);
assertNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0._detectBindAndClose(byteArray0, 1, 1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test296() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[3];
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT;
deserializationFeatureArray0[1] = deserializationFeature1;
DeserializationFeature deserializationFeature2 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
deserializationFeatureArray0[2] = deserializationFeature2;
ObjectReader objectReader1 = objectReader0.withFeatures(deserializationFeatureArray0);
assertEquals(3, deserializationFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withHandler(deserializationProblemHandler0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader3 = objectReader0.with(jsonNodeFactory0);
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
DeserializationFeature deserializationFeature3 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader4 = objectReader2.without(deserializationFeature3);
assertFalse(objectReader4.equals((Object)objectReader0));
assertFalse(objectReader4.equals((Object)objectReader3));
assertFalse(objectReader4.equals((Object)objectReader1));
assertFalse(objectReader4.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader3));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature1));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature2));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature0));
assertNotNull(objectReader4);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader4, objectReader0);
assertNotSame(objectReader4, objectReader3);
assertNotSame(objectReader4, objectReader1);
assertNotSame(objectReader4, objectReader2);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader4);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader4);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(deserializationFeature3, deserializationFeature1);
assertNotSame(deserializationFeature3, deserializationFeature2);
assertNotSame(deserializationFeature3, deserializationFeature0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)125;
byteArray0[1] = (byte)7;
byteArray0[2] = (byte)87;
byteArray0[3] = (byte)97;
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)118;
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray0);
assertArrayEquals(new byte[] {(byte)125, (byte)7, (byte)87, (byte)97, (byte)1, (byte)118}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(binaryNode0);
assertFalse(binaryNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isShort());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.booleanValue());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isLong());
assertFalse(binaryNode0.isMissingNode());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isIntegralNumber());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isArray());
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer((JavaType) null);
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader4));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader4);
assertNotSame(objectReader0, objectReader1);
// Undeclared exception!
try {
objectReader4._detectBindAndClose(byteArray0, (-3947), (-2032));
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test297() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
assertNotNull(jsonFactory0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
Class<ArrayType> class0 = ArrayType.class;
ObjectReader objectReader0 = objectMapper1.readerFor(class0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
InjectableValues injectableValues0 = objectReader0.getInjectableValues();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNull(injectableValues0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature0);
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature0.mappedFeature());
assertEquals(0, jsonReadFeature0.collectDefaults());
assertFalse(jsonReadFeature0.enabledByDefault());
assertEquals(128, jsonReadFeature0.getMask());
ObjectReader objectReader2 = objectReader0.without((FormatFeature) jsonReadFeature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature0.mappedFeature());
assertEquals(0, jsonReadFeature0.collectDefaults());
assertFalse(jsonReadFeature0.enabledByDefault());
assertEquals(128, jsonReadFeature0.getMask());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)43;
byteArray0[2] = (byte)43;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)3;
byteArray0[5] = (byte)1;
byteArray0[6] = (byte)0;
byteArray0[7] = (byte)78;
byteArray0[8] = (byte)0;
// Undeclared exception!
try {
objectReader1.readValues(byteArray0, (int) 43, 2000);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 43
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test298() throws Throwable {
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
assertNotNull(objectMapper0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
assertNotNull(contextAttributes0);
ObjectReader objectReader0 = objectMapper1.reader(contextAttributes0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
TypeFactory typeFactory0 = objectReader0.getTypeFactory();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(typeFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
JsonpCharacterEscapes jsonpCharacterEscapes0 = JsonpCharacterEscapes.instance();
assertNotNull(jsonpCharacterEscapes0);
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
assertNotNull(jsonFactory1);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectMapper1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory2);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_YAML_COMMENTS;
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonParser_Feature0, false);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(jsonFactory3);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)105;
byteArray0[1] = (byte) (-6);
byteArray0[2] = (byte)26;
byteArray0[3] = (byte)74;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)0;
UTF8StreamJsonParser uTF8StreamJsonParser0 = (UTF8StreamJsonParser)jsonFactory3.createParser(byteArray0);
assertArrayEquals(new byte[] {(byte)105, (byte) (-6), (byte)26, (byte)74, (byte)0, (byte)0}, byteArray0);
assertEquals(6, byteArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(uTF8StreamJsonParser0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory1.requiresCustomCodec());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertFalse(jsonFactory3.requiresCustomCodec());
assertEquals(8193, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(" ", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertNull(uTF8StreamJsonParser0.getLastClearedToken());
assertFalse(uTF8StreamJsonParser0.requiresCustomCodec());
assertEquals(8193, uTF8StreamJsonParser0.getFeatureMask());
assertFalse(uTF8StreamJsonParser0.canReadObjectId());
assertFalse(uTF8StreamJsonParser0.canReadTypeId());
assertEquals(1, uTF8StreamJsonParser0.getTokenLineNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartArrayToken());
assertFalse(uTF8StreamJsonParser0.hasCurrentToken());
assertNull(uTF8StreamJsonParser0.getCurrentName());
assertEquals(0, uTF8StreamJsonParser0.getFormatFeatures());
assertFalse(uTF8StreamJsonParser0.isClosed());
assertFalse(uTF8StreamJsonParser0.isNaN());
assertEquals(0, uTF8StreamJsonParser0.getCurrentTokenId());
assertNull(uTF8StreamJsonParser0.getCurrentToken());
assertNull(uTF8StreamJsonParser0.currentToken());
assertFalse(uTF8StreamJsonParser0.hasTextCharacters());
assertFalse(uTF8StreamJsonParser0.canParseAsync());
assertEquals(0L, uTF8StreamJsonParser0.getTokenCharacterOffset());
assertEquals(1, uTF8StreamJsonParser0.getTokenColumnNr());
assertFalse(uTF8StreamJsonParser0.isExpectedStartObjectToken());
assertEquals(0, uTF8StreamJsonParser0.currentTokenId());
assertEquals(0, CharacterEscapes.ESCAPE_NONE);
assertEquals((-2), CharacterEscapes.ESCAPE_CUSTOM);
assertEquals((-1), CharacterEscapes.ESCAPE_STANDARD);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory0);
try {
objectReader0._bindAndReadValues((JsonParser) uTF8StreamJsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Invalid UTF-8 start byte 0xfa
// at [Source: (byte[])\"i\uFFFD\u001AJ\u0000\u0000\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test299() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isMissingNode());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isMissingNode());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isMissingNode());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.currentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
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.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
char[] charArray0 = new char[3];
charArray0[1] = '/';
charArray0[2] = 'l';
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper0);
assertNotNull(jsonFactory1);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory0, jsonFactory1);
JsonFactory jsonFactory2 = jsonFactory1.setRootValueSeparator("JSON");
assertNotNull(jsonFactory2);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonParser_Feature0);
assertNotNull(jsonFactory3);
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals("JSON", jsonFactory1.getFormatName());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertTrue(jsonFactory3.canUseCharArrays());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory2);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory0, jsonFactory2);
ObjectMapper objectMapper1 = new ObjectMapper();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader1 = objectReader0.withoutRootName();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader0, objectReader1);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
SimpleValueInstantiators simpleValueInstantiators0 = new SimpleValueInstantiators();
assertNotNull(simpleValueInstantiators0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withValueInstantiators(simpleValueInstantiators0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
// Undeclared exception!
try {
objectReader0._findTreeDeserializer(defaultDeserializationContext_Impl0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DeserializerCache", e);
}
}
@Test(timeout = 4000)
public void test300() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(false);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_FALSE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.asBoolean());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertEquals("false", booleanNode0.asText());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, false);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(JsonToken.VALUE_FALSE, booleanNode0.asToken());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.asBoolean());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isFloat());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isBigDecimal());
assertTrue(booleanNode0.isEmpty());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isArray());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isBigInteger());
assertEquals("false", booleanNode0.asText());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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);
ByteArrayInputStream byteArrayInputStream1 = new ByteArrayInputStream(byteArray0, (-2631), 1114111);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArrayInputStream1.equals((Object)byteArrayInputStream0));
assertNotNull(byteArrayInputStream1);
assertEquals(2632, byteArrayInputStream1.available());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readValue((InputStream) byteArrayInputStream1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.ByteArrayInputStream", e);
}
}
@Test(timeout = 4000)
public void test301() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
// Undeclared exception!
try {
objectReader0.readValue((byte[]) null, 1513, 1513);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test302() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectReader objectReader1 = objectReader0.withFormatDetection((ObjectReader[]) null);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
String string0 = "\":PI:oY6*POR";
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.WRAP_EXCEPTIONS;
deserializationFeatureArray0[1] = deserializationFeature1;
DeserializationFeature deserializationFeature2 = DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES;
deserializationFeatureArray0[2] = deserializationFeature2;
DeserializationFeature deserializationFeature3 = DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE;
deserializationFeatureArray0[3] = deserializationFeature3;
DeserializationFeature deserializationFeature4 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
deserializationFeatureArray0[4] = deserializationFeature4;
DeserializationFeature deserializationFeature5 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
deserializationFeatureArray0[5] = deserializationFeature5;
DeserializationFeature deserializationFeature6 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
deserializationFeatureArray0[6] = deserializationFeature6;
// Undeclared exception!
try {
objectReader1.withFeatures(deserializationFeatureArray0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test303() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isLong());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isLong());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(iOContext0.isResourceManaged());
assertNull(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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isDouble());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isLong());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isObject());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isInt());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertTrue(booleanNode0.isEmpty());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isShort());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
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());
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);
char[] charArray0 = new char[3];
charArray0[1] = '/';
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.booleanValue());
assertTrue(arrayNode0.isEmpty());
assertFalse(arrayNode0.isObject());
assertEquals(0, arrayNode0.size());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloat());
ObjectNode objectNode0 = arrayNode0.insertObject(2);
assertNotNull(objectNode0);
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.booleanValue());
assertEquals(1, arrayNode0.size());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.isIntegralNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.isBigInteger());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
Short short0 = new Short((byte) (-49));
assertEquals((short) (-49), (short)short0);
assertNotNull(short0);
Short short1 = new Short((short)0);
assertEquals((short)0, (short)short1);
assertFalse(short1.equals((Object)short0));
assertNotNull(short1);
Short short2 = new Short((byte) (-49));
assertEquals((short) (-49), (short)short2);
assertFalse(short2.equals((Object)short1));
assertTrue(short2.equals((Object)short0));
assertNotNull(short2);
ObjectNode objectNode1 = objectNode0.put(" entries", short2);
assertFalse(short2.equals((Object)short1));
assertTrue(short2.equals((Object)short0));
assertNotNull(objectNode1);
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isBigDecimal());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isBigInteger());
assertNull(arrayNode0.textValue());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isDouble());
assertFalse(arrayNode0.booleanValue());
assertEquals(1, arrayNode0.size());
assertFalse(arrayNode0.isObject());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.isIntegralNumber());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isFloat());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode0.isIntegralNumber());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isLong());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isDouble());
assertFalse(objectNode0.isMissingNode());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isEmpty());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertFalse(objectNode0.isInt());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigInteger());
assertNull(objectNode0.textValue());
assertFalse(objectNode1.isBigDecimal());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.booleanValue());
assertFalse(objectNode1.isFloat());
assertEquals("", objectNode1.asText());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isArray());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertEquals(1, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isInt());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isBigInteger());
assertFalse(objectNode1.isEmpty());
assertFalse(objectNode1.isShort());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
JsonDeserializer<Object> jsonDeserializer0 = objectReader0._prefetchRootDeserializer((JavaType) null);
assertNull(jsonDeserializer0);
assertEquals(0, objectMapper0.mixInCount());
}
@Test(timeout = 4000)
public void test304() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
assertNotNull(defaultSerializerProvider_Impl0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
assertNotNull(beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
assertNotNull(objectMapper0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, objectMapper0.mixInCount());
DeserializationConfig deserializationConfig0 = defaultDeserializationContext_Impl0.getConfig();
assertNull(deserializationConfig0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
ObjectReader objectReader1 = null;
try {
objectReader1 = new ObjectReader(objectReader0, (DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test305() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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(3, BufferRecycler.CHAR_NAME_COPY_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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(0, booleanNode0.size());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isFloatingPointNumber());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertEquals(0, booleanNode0.size());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isShort());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertEquals("true", booleanNode0.asText());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isIntegralNumber());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertTrue(booleanNode0.booleanValue());
assertFalse(booleanNode0.isFloat());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
StringReader stringReader0 = new StringReader(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, true);
assertNotNull(jsonFactory1);
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectReader0);
assertNotNull(jsonFactory2);
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(95, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(95, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
ObjectReader objectReader1 = objectMapper1.reader();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(95, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader0, objectReader1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
ObjectReader objectReader2 = objectReader1.with(jsonNodeFactory0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(95, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader2);
assertNotSame(objectReader1, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES;
ObjectReader objectReader3 = objectReader1.without(deserializationFeature0);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader2));
assertFalse(objectReader1.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(objectReader3);
assertTrue(jsonFactory2.canParseAsync());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals(" ", jsonFactory2.getRootValueSeparator());
assertEquals("JSON", jsonFactory2.getFormatName());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(95, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertEquals(95, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertTrue(jsonFactory0.canParseAsync());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(95, jsonFactory1.getGeneratorFeatures());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader2);
assertSame(objectReader1, objectReader3);
assertNotSame(objectReader1, objectReader0);
assertSame(objectReader3, objectReader1);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory2);
ByteArrayInputStream byteArrayInputStream1 = new ByteArrayInputStream(byteArray0, 1, 1913);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertFalse(byteArrayInputStream1.equals((Object)byteArrayInputStream0));
assertNotNull(byteArrayInputStream1);
assertEquals(0, byteArrayInputStream1.available());
try {
objectReader2.readValue((InputStream) byteArrayInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '\u00CF': was expecting ('true', 'false' or 'null')
// at [Source: (ByteArrayInputStream); line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test306() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
LinkedHashSet<Object> linkedHashSet0 = new LinkedHashSet<Object>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(true));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
objectMapper0._registeredModuleTypes = (Set<Object>) linkedHashSet0;
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertTrue(objectMapper0._registeredModuleTypes.isEmpty());
assertEquals(0, objectMapper0._registeredModuleTypes.size());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
Class<AbstractDeserializer> class0 = AbstractDeserializer.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte) (-1);
FormatFeature[] formatFeatureArray0 = new FormatFeature[8];
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES;
assertEquals(JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES, jsonReadFeature0);
assertEquals(8, jsonReadFeature0.getMask());
assertEquals(0, jsonReadFeature0.collectDefaults());
assertFalse(jsonReadFeature0.enabledByDefault());
assertEquals(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, jsonReadFeature0.mappedFeature());
formatFeatureArray0[0] = (FormatFeature) jsonReadFeature0;
JsonReadFeature jsonReadFeature1 = JsonReadFeature.ALLOW_TRAILING_COMMA;
assertEquals(JsonReadFeature.ALLOW_TRAILING_COMMA, jsonReadFeature1);
assertFalse(jsonReadFeature1.equals((Object)jsonReadFeature0));
assertEquals(JsonParser.Feature.ALLOW_TRAILING_COMMA, jsonReadFeature1.mappedFeature());
assertEquals(512, jsonReadFeature1.getMask());
assertEquals(0, jsonReadFeature1.collectDefaults());
assertFalse(jsonReadFeature1.enabledByDefault());
assertNotSame(jsonReadFeature1, jsonReadFeature0);
formatFeatureArray0[1] = (FormatFeature) jsonReadFeature1;
JsonWriteFeature jsonWriteFeature0 = JsonWriteFeature.QUOTE_FIELD_NAMES;
assertEquals(JsonWriteFeature.QUOTE_FIELD_NAMES, jsonWriteFeature0);
assertTrue(jsonWriteFeature0.enabledByDefault());
assertEquals(3, jsonWriteFeature0.collectDefaults());
assertEquals(1, jsonWriteFeature0.getMask());
assertEquals(JsonGenerator.Feature.QUOTE_FIELD_NAMES, jsonWriteFeature0.mappedFeature());
formatFeatureArray0[2] = (FormatFeature) jsonWriteFeature0;
JsonReadFeature jsonReadFeature2 = JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature2);
assertFalse(jsonReadFeature2.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature2.equals((Object)jsonReadFeature1));
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature2.mappedFeature());
assertEquals(128, jsonReadFeature2.getMask());
assertEquals(0, jsonReadFeature2.collectDefaults());
assertFalse(jsonReadFeature2.enabledByDefault());
assertNotSame(jsonReadFeature2, jsonReadFeature0);
assertNotSame(jsonReadFeature2, jsonReadFeature1);
formatFeatureArray0[3] = (FormatFeature) jsonReadFeature2;
JsonReadFeature jsonReadFeature3 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS, jsonReadFeature3);
assertFalse(jsonReadFeature3.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature3.equals((Object)jsonReadFeature1));
assertFalse(jsonReadFeature3.equals((Object)jsonReadFeature2));
assertEquals(0, jsonReadFeature3.collectDefaults());
assertEquals(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, jsonReadFeature3.mappedFeature());
assertEquals(64, jsonReadFeature3.getMask());
assertFalse(jsonReadFeature3.enabledByDefault());
assertNotSame(jsonReadFeature3, jsonReadFeature0);
assertNotSame(jsonReadFeature3, jsonReadFeature1);
assertNotSame(jsonReadFeature3, jsonReadFeature2);
formatFeatureArray0[4] = (FormatFeature) jsonReadFeature3;
JsonReadFeature jsonReadFeature4 = JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS;
assertEquals(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS, jsonReadFeature4);
assertFalse(jsonReadFeature4.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature4.equals((Object)jsonReadFeature3));
assertFalse(jsonReadFeature4.equals((Object)jsonReadFeature2));
assertFalse(jsonReadFeature4.equals((Object)jsonReadFeature1));
assertEquals(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, jsonReadFeature4.mappedFeature());
assertEquals(0, jsonReadFeature4.collectDefaults());
assertFalse(jsonReadFeature4.enabledByDefault());
assertEquals(16, jsonReadFeature4.getMask());
assertNotSame(jsonReadFeature4, jsonReadFeature0);
assertNotSame(jsonReadFeature4, jsonReadFeature3);
assertNotSame(jsonReadFeature4, jsonReadFeature2);
assertNotSame(jsonReadFeature4, jsonReadFeature1);
formatFeatureArray0[5] = (FormatFeature) jsonReadFeature4;
JsonReadFeature jsonReadFeature5 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS, jsonReadFeature5);
assertFalse(jsonReadFeature5.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature5.equals((Object)jsonReadFeature1));
assertFalse(jsonReadFeature5.equals((Object)jsonReadFeature4));
assertFalse(jsonReadFeature5.equals((Object)jsonReadFeature2));
assertEquals(0, jsonReadFeature5.collectDefaults());
assertEquals(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, jsonReadFeature5.mappedFeature());
assertFalse(jsonReadFeature5.enabledByDefault());
assertEquals(64, jsonReadFeature5.getMask());
assertNotSame(jsonReadFeature5, jsonReadFeature0);
assertNotSame(jsonReadFeature5, jsonReadFeature1);
assertSame(jsonReadFeature5, jsonReadFeature3);
assertNotSame(jsonReadFeature5, jsonReadFeature4);
assertNotSame(jsonReadFeature5, jsonReadFeature2);
formatFeatureArray0[6] = (FormatFeature) jsonReadFeature5;
JsonReadFeature jsonReadFeature6 = JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS;
assertEquals(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature6);
assertFalse(jsonReadFeature6.equals((Object)jsonReadFeature4));
assertFalse(jsonReadFeature6.equals((Object)jsonReadFeature5));
assertFalse(jsonReadFeature6.equals((Object)jsonReadFeature0));
assertFalse(jsonReadFeature6.equals((Object)jsonReadFeature1));
assertFalse(jsonReadFeature6.equals((Object)jsonReadFeature3));
assertFalse(jsonReadFeature6.enabledByDefault());
assertEquals(0, jsonReadFeature6.collectDefaults());
assertEquals(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, jsonReadFeature6.mappedFeature());
assertEquals(128, jsonReadFeature6.getMask());
assertNotSame(jsonReadFeature6, jsonReadFeature4);
assertNotSame(jsonReadFeature6, jsonReadFeature5);
assertNotSame(jsonReadFeature6, jsonReadFeature0);
assertNotSame(jsonReadFeature6, jsonReadFeature1);
assertSame(jsonReadFeature6, jsonReadFeature2);
assertNotSame(jsonReadFeature6, jsonReadFeature3);
formatFeatureArray0[7] = (FormatFeature) jsonReadFeature6;
ObjectReader objectReader1 = objectReader0.withoutFeatures(formatFeatureArray0);
assertEquals(8, formatFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
byteArray0[1] = (byte) (-12);
byte[] byteArray1 = new byte[5];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)1;
byteArray1[1] = (byte)118;
byteArray1[2] = (byte) (-1);
byteArray1[3] = (byte)7;
byteArray1[4] = (byte) (-12);
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray1);
assertArrayEquals(new byte[] {(byte)1, (byte)118, (byte) (-1), (byte)7, (byte) (-12)}, byteArray1);
assertEquals(5, byteArray1.length);
assertFalse(byteArray1.equals((Object)byteArray0));
assertNotNull(binaryNode0);
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isLong());
assertNull(binaryNode0.textValue());
assertFalse(binaryNode0.isMissingNode());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isArray());
assertTrue(binaryNode0.isEmpty());
assertFalse(binaryNode0.isBigDecimal());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isInt());
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isShort());
assertFalse(binaryNode0.booleanValue());
assertFalse(binaryNode0.isObject());
assertNotSame(byteArray1, byteArray0);
Class<ObjectNode> class1 = ObjectNode.class;
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) binaryNode0, class1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test307() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
Class<Object> class0 = Object.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[3];
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT;
deserializationFeatureArray0[1] = deserializationFeature1;
DeserializationFeature deserializationFeature2 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
deserializationFeatureArray0[2] = deserializationFeature2;
ObjectReader objectReader1 = objectReader0.withFeatures(deserializationFeatureArray0);
assertEquals(3, deserializationFeatureArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withHandler(deserializationProblemHandler0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader3 = objectReader0.with(jsonNodeFactory0);
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader2));
assertFalse(objectReader3.equals((Object)objectReader0));
assertFalse(objectReader3.equals((Object)objectReader1));
assertNotNull(objectReader3);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader3, objectReader2);
assertNotSame(objectReader3, objectReader0);
assertNotSame(objectReader3, objectReader1);
DeserializationFeature deserializationFeature3 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader4 = objectReader2.without(deserializationFeature3);
assertFalse(objectReader4.equals((Object)objectReader1));
assertFalse(objectReader4.equals((Object)objectReader0));
assertFalse(objectReader4.equals((Object)objectReader3));
assertFalse(objectReader4.equals((Object)objectReader2));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader3));
assertFalse(objectReader0.equals((Object)objectReader2));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader3));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature0));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature1));
assertFalse(deserializationFeature3.equals((Object)deserializationFeature2));
assertNotNull(objectReader4);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader4, objectReader1);
assertNotSame(objectReader4, objectReader0);
assertNotSame(objectReader4, objectReader3);
assertNotSame(objectReader4, objectReader2);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader3);
assertNotSame(objectReader0, objectReader2);
assertNotSame(objectReader0, objectReader4);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader3);
assertNotSame(objectReader2, objectReader4);
assertNotSame(deserializationFeature3, deserializationFeature0);
assertNotSame(deserializationFeature3, deserializationFeature1);
assertNotSame(deserializationFeature3, deserializationFeature2);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)125;
byteArray0[1] = (byte)7;
byteArray0[2] = (byte)87;
byteArray0[3] = (byte)97;
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)118;
BinaryNode binaryNode0 = BinaryNode.valueOf(byteArray0);
assertArrayEquals(new byte[] {(byte)125, (byte)7, (byte)87, (byte)97, (byte)1, (byte)118}, byteArray0);
assertEquals(6, byteArray0.length);
assertNotNull(binaryNode0);
assertNull(binaryNode0.numberType());
assertFalse(binaryNode0.isObject());
assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, binaryNode0.asToken());
assertFalse(binaryNode0.isArray());
assertFalse(binaryNode0.isInt());
assertFalse(binaryNode0.isDouble());
assertFalse(binaryNode0.isIntegralNumber());
assertFalse(binaryNode0.isShort());
assertFalse(binaryNode0.isMissingNode());
assertTrue(binaryNode0.isEmpty());
assertNull(binaryNode0.textValue());
assertEquals(JsonNodeType.BINARY, binaryNode0.getNodeType());
assertFalse(binaryNode0.isBigInteger());
assertFalse(binaryNode0.isFloatingPointNumber());
assertFalse(binaryNode0.isFloat());
assertFalse(binaryNode0.isLong());
assertEquals(0, binaryNode0.size());
assertFalse(binaryNode0.isBigDecimal());
assertFalse(binaryNode0.booleanValue());
Class<ObjectNode> class1 = ObjectNode.class;
// Undeclared exception!
try {
objectReader0.treeToValue((TreeNode) binaryNode0, class1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test308() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
byte[] byteArray0 = new byte[5];
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(5, byteArrayInputStream0.available());
ObjectReader objectReader1 = objectReader0.withValueToUpdate(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(5, byteArray0.length);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(5, byteArrayInputStream0.available());
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader1, objectReader0);
// Undeclared exception!
try {
objectReader0.at("pIs`");
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Invalid input: JSON Pointer expression must start with '/': \"pIs`\"
//
verifyException("com.fasterxml.jackson.core.JsonPointer", e);
}
}
@Test(timeout = 4000)
public void test309() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
boolean boolean0 = objectReader0.isEnabled(deserializationFeature0);
assertFalse(boolean0);
assertEquals(0, objectMapper0.mixInCount());
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
assertEquals(0, objectReaderArray0.length);
assertNotNull(dataFormatReaders0);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.isJavaLangObject());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.useStaticType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isCollectionLikeType());
LinkedHashSet<Object> linkedHashSet0 = new LinkedHashSet<Object>();
assertNotNull(linkedHashSet0);
assertFalse(linkedHashSet0.contains(true));
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
objectMapper0._registeredModuleTypes = (Set<Object>) linkedHashSet0;
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, linkedHashSet0.size());
assertTrue(linkedHashSet0.isEmpty());
assertEquals(0, objectMapper0._registeredModuleTypes.size());
assertTrue(objectMapper0._registeredModuleTypes.isEmpty());
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(0);
assertEquals(0, objectReaderArray0.length);
assertFalse(dataFormatReaders1.equals((Object)dataFormatReaders0));
assertNotNull(dataFormatReaders1);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertEquals(64, DataFormatReaders.DEFAULT_MAX_INPUT_LOOKAHEAD);
assertNotSame(dataFormatReaders0, dataFormatReaders1);
assertNotSame(dataFormatReaders1, dataFormatReaders0);
Class<AbstractDeserializer> class1 = AbstractDeserializer.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class1);
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectReader1, objectReader0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte) (-12);
byteArray0[2] = (byte)78;
byteArray0[3] = (byte)43;
byteArray0[4] = (byte)43;
byteArray0[5] = (byte)2;
ObjectMapper objectMapper1 = objectMapper0.clearProblemHandlers();
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, objectMapper1.mixInCount());
assertSame(objectMapper0, objectMapper1);
assertSame(objectMapper1, objectMapper0);
MockFile mockFile0 = new MockFile("", "No content to map due to end-of-input");
assertNotNull(mockFile0);
File file0 = MockFile.createTempFile(" with format auto-detection: must be byte- not char-based", "", (File) mockFile0);
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(file0);
assertEquals("/No content to map due to end-of-input", mockFile0.toString());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertTrue(mockFile0.isDirectory());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertTrue(mockFile0.canExecute());
assertEquals("/", mockFile0.getParent());
assertEquals("No content to map due to end-of-input", mockFile0.getName());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isAbsolute());
assertFalse(mockFile0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals("/No content to map due to end-of-input", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" with format auto-detection: must be byte- not char-based0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.isAbsolute());
assertEquals("/No content to map due to end-of-input/ with format auto-detection: must be byte- not char-based0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertNotSame(mockFile0, file0);
assertNotSame(file0, mockFile0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(file0);
assertFalse(mockFile0.equals((Object)file0));
assertFalse(file0.equals((Object)mockFile0));
assertNotNull(mockFileInputStream0);
// Undeclared exception!
try {
objectReader0._detectBindAndCloseAsTree(mockFileInputStream0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test310() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
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());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.currentTokenId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.currentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
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);
char[] charArray0 = new char[3];
charArray0[0] = 'w';
charArray0[1] = '/';
charArray0[2] = 'l';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectMapper0, charsToNameCanonicalizer0, charArray0, (byte) (-49), 1257, false);
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
FormatSchema formatSchema0 = readerBasedJsonParser1.getSchema();
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(formatSchema0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
JsonFactory jsonFactory0 = new JsonFactory();
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper0);
assertNotNull(jsonFactory1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
JsonFactory jsonFactory2 = jsonFactory1.setRootValueSeparator("JSON");
assertNotNull(jsonFactory2);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(8193, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonParser_Feature0);
assertNotNull(jsonFactory3);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory3);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
ObjectReader objectReader1 = objectMapper1.reader((FormatSchema) null);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertEquals(0, objectMapper0.mixInCount());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(8257, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getRootValueSeparator());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.requiresCustomCodec());
assertEquals(31, jsonFactory1.getGeneratorFeatures());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8257, jsonFactory1.getParserFeatures());
assertEquals("JSON", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertFalse(jsonFactory2.requiresPropertyOrdering());
assertEquals(0, jsonFactory2.getFormatGeneratorFeatures());
assertTrue(jsonFactory2.canUseCharArrays());
assertEquals("JSON", jsonFactory2.getFormatName());
assertEquals("JSON", jsonFactory2.getRootValueSeparator());
assertEquals(8257, jsonFactory2.getParserFeatures());
assertTrue(jsonFactory2.canParseAsync());
assertEquals(31, jsonFactory2.getGeneratorFeatures());
assertFalse(jsonFactory2.requiresCustomCodec());
assertEquals(0, jsonFactory2.getFormatParserFeatures());
assertFalse(jsonFactory2.canHandleBinaryNatively());
assertEquals("JSON", jsonFactory3.getRootValueSeparator());
assertEquals(31, jsonFactory3.getGeneratorFeatures());
assertEquals(8257, jsonFactory3.getParserFeatures());
assertTrue(jsonFactory3.canUseCharArrays());
assertEquals(0, jsonFactory3.getFormatGeneratorFeatures());
assertEquals("JSON", jsonFactory3.getFormatName());
assertFalse(jsonFactory3.requiresCustomCodec());
assertFalse(jsonFactory3.requiresPropertyOrdering());
assertFalse(jsonFactory3.canHandleBinaryNatively());
assertTrue(jsonFactory3.canParseAsync());
assertEquals(0, jsonFactory3.getFormatParserFeatures());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory0, jsonFactory2);
assertSame(jsonFactory0, jsonFactory3);
assertSame(jsonFactory1, jsonFactory2);
assertSame(jsonFactory1, jsonFactory0);
assertSame(jsonFactory1, jsonFactory3);
assertSame(jsonFactory2, jsonFactory0);
assertSame(jsonFactory2, jsonFactory1);
assertSame(jsonFactory2, jsonFactory3);
assertSame(jsonFactory3, jsonFactory1);
assertSame(jsonFactory3, jsonFactory0);
assertSame(jsonFactory3, jsonFactory2);
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
ObjectReader objectReader2 = objectReader0.withoutRootName();
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader1));
assertNotNull(objectReader2);
assertEquals(0, objectMapper0.mixInCount());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(objectReader2, objectReader0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
MappingIterator<FilteringParserDelegate> mappingIterator0 = objectReader0.readValues((JsonParser) readerBasedJsonParser1);
assertArrayEquals(new char[] {'w', '/', 'l'}, charArray0);
assertEquals(3, charArray0.length);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(objectReader0.equals((Object)objectReader1));
assertFalse(objectReader0.equals((Object)objectReader2));
assertNotNull(mappingIterator0);
assertEquals(0, objectMapper0.mixInCount());
assertEquals(0, readerBasedJsonParser1.currentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canParseAsync());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isNaN());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.currentToken());
assertFalse(booleanNode0.isFloatingPointNumber());
assertNull(booleanNode0.textValue());
assertFalse(booleanNode0.isFloat());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isBigInteger());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertTrue(booleanNode0.asBoolean());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isArray());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isLong());
assertEquals("true", booleanNode0.asText());
assertFalse(booleanNode0.isBigDecimal());
assertEquals(0, booleanNode0.size());
assertNull(booleanNode0.numberType());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
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);
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader0, objectReader2);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
assertNotNull(deserializerFactoryConfig0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
assertNotNull(beanDeserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
SimpleValueInstantiators simpleValueInstantiators0 = new SimpleValueInstantiators();
assertNotNull(simpleValueInstantiators0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withValueInstantiators(simpleValueInstantiators0);
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(deserializerFactory0);
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext_Impl0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.copy();
assertFalse(defaultDeserializationContext0.equals((Object)defaultDeserializationContext_Impl0));
assertFalse(beanDeserializerFactory0.equals((Object)deserializerFactory0));
assertFalse(deserializerFactory0.equals((Object)beanDeserializerFactory0));
assertNotNull(defaultDeserializationContext0);
assertEquals(0, defaultDeserializationContext_Impl0.getDeserializationFeatures());
assertEquals(0, defaultDeserializationContext0.getDeserializationFeatures());
assertFalse(deserializerFactoryConfig0.hasDeserializerModifiers());
assertFalse(deserializerFactoryConfig0.hasDeserializers());
assertFalse(deserializerFactoryConfig0.hasValueInstantiators());
assertTrue(deserializerFactoryConfig0.hasKeyDeserializers());
assertFalse(deserializerFactoryConfig0.hasAbstractTypeResolvers());
assertNotSame(defaultDeserializationContext_Impl0, defaultDeserializationContext0);
assertNotSame(defaultDeserializationContext0, defaultDeserializationContext_Impl0);
assertNotSame(beanDeserializerFactory0, deserializerFactory0);
assertNotSame(deserializerFactory0, beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader1._findTreeDeserializer(defaultDeserializationContext0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DeserializerCache", e);
}
}
@Test(timeout = 4000)
public void test311() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(1, byteArrayInputStream0.available());
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
assertNotNull(dataInputStream0);
assertEquals(1, byteArrayInputStream0.available());
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);
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
assertNotNull(booleanNode0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloat());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
assertNotNull(iOContext0);
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloat());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
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(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(" entries");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-49)}, byteArray0);
assertEquals(1, byteArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertNotNull(charsToNameCanonicalizer0);
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, objectMapper0.mixInCount());
assertFalse(booleanNode0.isMissingNode());
assertFalse(booleanNode0.isLong());
assertFalse(booleanNode0.isDouble());
assertFalse(booleanNode0.isShort());
assertFalse(booleanNode0.isInt());
assertFalse(booleanNode0.isFloatingPointNumber());
assertFalse(booleanNode0.isArray());
assertFalse(booleanNode0.isBigInteger());
assertNull(booleanNode0.textValue());
assertTrue(booleanNode0.isEmpty());
assertTrue(booleanNode0.booleanValue());
assertEquals(JsonNodeType.BOOLEAN, booleanNode0.getNodeType());
assertFalse(booleanNode0.isBigDecimal());
assertFalse(booleanNode0.isObject());
assertFalse(booleanNode0.isIntegralNumber());
assertFalse(booleanNode0.isFloat());
assertTrue(booleanNode0.asBoolean());
assertNull(booleanNode0.numberType());
assertEquals(JsonToken.VALUE_TRUE, booleanNode0.asToken());
assertEquals("true", booleanNode0.asText());
assertEquals(0, booleanNode0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
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(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isNaN());
assertFalse(readerBasedJsonParser0.canParseAsync());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
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);
char[] charArray0 = new char[3];
charArray0[0] = 'w';
charArray0[1] = '/';
charArray0[2] = 'l';
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
assertNotNull(jsonNodeFactory0);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
assertNotNull(arrayNode0);
assertFalse(arrayNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isFloat());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isMissingNode());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isShort());
assertTrue(arrayNode0.isEmpty());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(0, arrayNode0.size());
ObjectNode objectNode0 = arrayNode0.insertObject(0);
assertNotNull(objectNode0);
assertFalse(arrayNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isFloat());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isMissingNode());
assertEquals(1, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isShort());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertEquals(0, objectNode0.size());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isInt());
assertTrue(objectNode0.isEmpty());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
Short short0 = new Short((byte) (-49));
assertEquals((short) (-49), (short)short0);
assertNotNull(short0);
Short short1 = new Short((short)0);
assertEquals((short)0, (short)short1);
assertFalse(short1.equals((Object)short0));
assertNotNull(short1);
Short short2 = new Short((byte) (-49));
assertEquals((short) (-49), (short)short2);
assertFalse(short2.equals((Object)short1));
assertTrue(short2.equals((Object)short0));
assertNotNull(short2);
ObjectNode objectNode1 = objectNode0.put(" entries", short2);
assertFalse(short2.equals((Object)short1));
assertTrue(short2.equals((Object)short0));
assertNotNull(objectNode1);
assertFalse(arrayNode0.isBigInteger());
assertEquals(JsonToken.START_ARRAY, arrayNode0.asToken());
assertNull(arrayNode0.textValue());
assertFalse(arrayNode0.isFloat());
assertNull(arrayNode0.numberType());
assertFalse(arrayNode0.booleanValue());
assertFalse(arrayNode0.isInt());
assertFalse(arrayNode0.isBigDecimal());
assertFalse(arrayNode0.isObject());
assertFalse(arrayNode0.isMissingNode());
assertEquals(1, arrayNode0.size());
assertFalse(arrayNode0.isLong());
assertFalse(arrayNode0.isFloatingPointNumber());
assertFalse(arrayNode0.isDouble());
assertTrue(arrayNode0.isArray());
assertFalse(arrayNode0.isEmpty());
assertFalse(arrayNode0.isShort());
assertEquals(JsonNodeType.ARRAY, arrayNode0.getNodeType());
assertEquals("", arrayNode0.asText());
assertFalse(arrayNode0.isIntegralNumber());
assertNull(objectNode0.textValue());
assertFalse(objectNode0.isFloat());
assertFalse(objectNode0.isFloatingPointNumber());
assertEquals(1, objectNode0.size());
assertFalse(objectNode0.isBigInteger());
assertFalse(objectNode0.isMissingNode());
assertFalse(objectNode0.isLong());
assertEquals(JsonNodeType.OBJECT, objectNode0.getNodeType());
assertFalse(objectNode0.isDouble());
assertEquals("", objectNode0.asText());
assertFalse(objectNode0.isArray());
assertFalse(objectNode0.isIntegralNumber());
assertFalse(objectNode0.isEmpty());
assertTrue(objectNode0.isObject());
assertFalse(objectNode0.isShort());
assertEquals(JsonToken.START_OBJECT, objectNode0.asToken());
assertFalse(objectNode0.isInt());
assertFalse(objectNode0.booleanValue());
assertNull(objectNode0.numberType());
assertFalse(objectNode0.isBigDecimal());
assertFalse(objectNode1.isBigInteger());
assertEquals(JsonToken.START_OBJECT, objectNode1.asToken());
assertFalse(objectNode1.isFloat());
assertEquals(1, objectNode1.size());
assertNull(objectNode1.textValue());
assertFalse(objectNode1.isBigDecimal());
assertFalse(objectNode1.isEmpty());
assertTrue(objectNode1.isObject());
assertFalse(objectNode1.isShort());
assertFalse(objectNode1.isInt());
assertFalse(objectNode1.booleanValue());
assertEquals(JsonNodeType.OBJECT, objectNode1.getNodeType());
assertNull(objectNode1.numberType());
assertFalse(objectNode1.isMissingNode());
assertFalse(objectNode1.isLong());
assertFalse(objectNode1.isFloatingPointNumber());
assertFalse(objectNode1.isIntegralNumber());
assertFalse(objectNode1.isDouble());
assertFalse(objectNode1.isArray());
assertEquals("", objectNode1.asText());
assertSame(objectNode0, objectNode1);
assertSame(objectNode1, objectNode0);
// Undeclared exception!
try {
objectReader0.readValue((JsonNode) objectNode0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test312() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
PipedReader pipedReader0 = new PipedReader();
assertNotNull(pipedReader0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_TARGET;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
assertNotNull(jsonFactory1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1);
assertNotNull(objectMapper0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
ObjectReader objectReader0 = objectMapper0.reader();
assertNotNull(objectReader0);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
byte[] byteArray0 = new byte[20];
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)56;
byteArray0[3] = (byte) (-106);
byteArray0[4] = (byte)1;
byteArray0[5] = (byte) (-98);
byteArray0[6] = (byte)56;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(20, byteArray0.length);
assertNotNull(byteArrayInputStream0);
assertEquals(20, byteArrayInputStream0.available());
ObjectReader objectReader1 = objectReader0.withValueToUpdate((Object) null);
assertNotNull(objectReader1);
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals("JSON", jsonFactory0.getFormatName());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals(30, jsonFactory0.getGeneratorFeatures());
assertFalse(jsonFactory0.requiresCustomCodec());
assertFalse(jsonFactory1.requiresPropertyOrdering());
assertEquals(0, jsonFactory1.getFormatGeneratorFeatures());
assertEquals(30, jsonFactory1.getGeneratorFeatures());
assertFalse(jsonFactory1.requiresCustomCodec());
assertTrue(jsonFactory1.canUseCharArrays());
assertEquals(8193, jsonFactory1.getParserFeatures());
assertTrue(jsonFactory1.canParseAsync());
assertEquals(" ", jsonFactory1.getRootValueSeparator());
assertEquals(0, jsonFactory1.getFormatParserFeatures());
assertEquals("JSON", jsonFactory1.getFormatName());
assertFalse(jsonFactory1.canHandleBinaryNatively());
assertEquals(0, objectMapper0.mixInCount());
assertSame(jsonFactory0, jsonFactory1);
assertSame(jsonFactory1, jsonFactory0);
assertSame(objectReader0, objectReader1);
assertSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test313() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
assertNotNull(objectMapper0);
assertEquals(0, objectMapper0.mixInCount());
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
assertNotNull(jsonNodeFactory0);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
assertNotNull(objectReader0);
assertEquals(0, objectMapper0.mixInCount());
Class<ReferenceType> class0 = ReferenceType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.isJavaLangObject());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.hasValueHandler());
assertFalse(simpleType0.hasHandlers());
assertFalse(simpleType0.isEnumType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.isFinal());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.isContainerType());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isAbstract());
assertEquals(0, simpleType0.containedTypeCount());
objectReader0._verifySchemaType((FormatSchema) null);
assertEquals(0, objectMapper0.mixInCount());
try {
objectReader0.readTree("Gf~MvX3x%>6S:3x4#");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'Gf': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"Gf~MvX3x%>6S:3x4#\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test314() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
assertNotNull(jsonFactory0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
assertNotNull(objectMapper0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectMapper1);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "JSON");
assertFalse(boolean0);
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader();
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertNotNull(objectReader0);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
ObjectReader objectReader1 = objectMapper1.reader(deserializationFeature0);
assertFalse(objectMapper1.equals((Object)objectMapper0));
assertFalse(objectReader1.equals((Object)objectReader0));
assertNotNull(objectReader1);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper1.mixInCount());
assertNotSame(objectMapper1, objectMapper0);
assertNotSame(objectReader1, objectReader0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
assertNotNull(simpleType0);
assertFalse(simpleType0.isArrayType());
assertFalse(simpleType0.isPrimitive());
assertFalse(simpleType0.isInterface());
assertFalse(simpleType0.hasHandlers());
assertTrue(simpleType0.isConcrete());
assertFalse(simpleType0.isJavaLangObject());
assertTrue(simpleType0.isFinal());
assertFalse(simpleType0.isEnumType());
assertEquals(0, simpleType0.containedTypeCount());
assertFalse(simpleType0.isAbstract());
assertFalse(simpleType0.isCollectionLikeType());
assertFalse(simpleType0.useStaticType());
assertFalse(simpleType0.hasContentType());
assertFalse(simpleType0.isContainerType());
assertFalse(simpleType0.isMapLikeType());
assertFalse(simpleType0.hasValueHandler());
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
assertNotNull(contextAttributes0);
ConcurrentHashMap<ObjectNode, MapLikeType> concurrentHashMap0 = new ConcurrentHashMap<ObjectNode, MapLikeType>();
assertNotNull(concurrentHashMap0);
assertTrue(concurrentHashMap0.isEmpty());
ContextAttributes contextAttributes1 = contextAttributes0.withSharedAttributes(concurrentHashMap0);
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertNotNull(contextAttributes1);
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes0);
ObjectReader objectReader2 = objectMapper0.reader(contextAttributes1);
assertFalse(objectMapper0.equals((Object)objectMapper1));
assertFalse(contextAttributes0.equals((Object)contextAttributes1));
assertFalse(contextAttributes1.equals((Object)contextAttributes0));
assertFalse(objectReader2.equals((Object)objectReader1));
assertFalse(objectReader2.equals((Object)objectReader0));
assertNotNull(objectReader2);
assertTrue(jsonFactory0.canUseCharArrays());
assertEquals(" ", jsonFactory0.getRootValueSeparator());
assertEquals(31, jsonFactory0.getGeneratorFeatures());
assertEquals(8193, jsonFactory0.getParserFeatures());
assertEquals("JSON", jsonFactory0.getFormatName());
assertFalse(jsonFactory0.requiresCustomCodec());
assertEquals(0, jsonFactory0.getFormatParserFeatures());
assertFalse(jsonFactory0.requiresPropertyOrdering());
assertFalse(jsonFactory0.canHandleBinaryNatively());
assertEquals(0, jsonFactory0.getFormatGeneratorFeatures());
assertTrue(jsonFactory0.canParseAsync());
assertEquals(0, objectMapper0.mixInCount());
assertTrue(concurrentHashMap0.isEmpty());
assertNotSame(objectMapper0, objectMapper1);
assertNotSame(contextAttributes0, contextAttributes1);
assertNotSame(contextAttributes1, contextAttributes0);
assertNotSame(objectReader2, objectReader1);
assertNotSame(objectReader2, objectReader0);
// Undeclared exception!
try {
objectReader2.readValue((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test315() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectMapper objectMapper1 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte) (-57);
byteArray0[1] = (byte) (-57);
byteArray0[2] = (byte) (-57);
byteArray0[3] = (byte) (-57);
byteArray0[4] = (byte) (-57);
byteArray0[5] = (byte)2;
byteArray0[6] = (byte)71;
byteArray0[7] = (byte) (-57);
byteArray0[8] = (byte) (-57);
try {
objectReader0.readValue(byteArray0, 0, 2530);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Invalid UTF-8 middle byte 0xc7
// at [Source: (byte[])\"\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0002G\uFFFD\uFFFD\"; line: 1, column: 4]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test316() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
// Undeclared exception!
try {
objectReader0.without(deserializationFeature0, (DeserializationFeature[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationConfig", e);
}
}
@Test(timeout = 4000)
public void test317() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType.constructUnsafe(class0);
LinkedHashSet<Object> linkedHashSet0 = new LinkedHashSet<Object>();
objectMapper0._registeredModuleTypes = (Set<Object>) linkedHashSet0;
dataFormatReaders0.withMaxInputLookahead(0);
Class<AbstractDeserializer> class1 = AbstractDeserializer.class;
ObjectReader objectReader1 = objectMapper0.readerFor(class1);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte) (-12);
byteArray0[2] = (byte)78;
byteArray0[3] = (byte)43;
byteArray0[4] = (byte)3;
byteArray0[5] = (byte)2;
byteArray0[6] = (byte)69;
byteArray0[7] = (byte)1;
byteArray0[8] = (byte) (-119);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 65536, 64);
// Undeclared exception!
try {
objectReader1.readValue((InputStream) byteArrayInputStream0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test318() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl0.copy();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
SimpleDeserializers simpleDeserializers0 = new SimpleDeserializers();
deserializerFactoryConfig0.withAdditionalDeserializers(simpleDeserializers0);
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.copy();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider0, defaultDeserializationContext0);
HashMap<String, Object> hashMap0 = new HashMap<String, Object>();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(hashMap0);
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class0, (Object) jsonFactoryBuilder0);
ObjectReader objectReader0 = objectMapper0.reader((InjectableValues) injectableValues_Std1);
ObjectReader objectReader1 = objectReader0.with(jsonFactory0);
injectableValues_Std0.addValue((Class<?>) class0, (Object) jsonFactory0);
objectReader1.version();
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader2 = objectReader0.without(deserializationFeature0);
ContextAttributes contextAttributes0 = ContextAttributes.getEmpty();
ObjectReader objectReader3 = objectReader0.with(contextAttributes0);
assertNotSame(objectReader0, objectReader2);
assertSame(objectReader3, objectReader1);
}
@Test(timeout = 4000)
public void test319() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
ConcurrentHashMap<FilteringParserDelegate, String> concurrentHashMap0 = new ConcurrentHashMap<FilteringParserDelegate, String>();
ContextAttributes contextAttributes1 = contextAttributes0.withSharedAttributes(concurrentHashMap0);
ContextAttributes contextAttributes2 = contextAttributes1.withoutSharedAttribute(jsonNodeFactory0);
objectReader0.with(contextAttributes2);
// Undeclared exception!
try {
objectReader0.readValues("");
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test320() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
NioPathDeserializer nioPathDeserializer0 = new NioPathDeserializer();
IOContext iOContext0 = new IOContext(bufferRecycler0, nioPathDeserializer0, true);
StringReader stringReader0 = new StringReader(" entries");
Short short0 = new Short((byte)0);
Short short1 = new Short((byte) (-95));
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
String[] stringArray0 = new String[6];
stringArray0[0] = " entries";
stringArray0[1] = "JSON";
stringArray0[2] = " entries";
stringArray0[3] = " entries";
stringArray0[4] = " entries";
stringArray0[5] = " entries";
ObjectNode objectNode1 = objectNode0.retain(stringArray0);
objectNode1.put("com.fasterxml.jackson.core.format.MatchStrength", short0);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory0);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
try {
objectReader1._reportUndetectableSource(jsonNodeFactory0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Cannot use source of type com.fasterxml.jackson.databind.node.JsonNodeFactory with format auto-detection: must be byte- not char-based
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test321() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-57);
System.setCurrentTimeMillis(210L);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
// Undeclared exception!
try {
objectReader0.readValues((Reader) null);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test322() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
StringReader stringReader0 = new StringReader(" entries");
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte) (-95);
byteArray0[1] = (byte) (-104);
byteArray0[2] = (byte)0;
byteArray0[4] = (byte) (-83);
Short short0 = new Short((short)4011);
Short short1 = new Short((byte)2);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ObjectNode objectNode0 = jsonNodeFactory0.objectNode();
objectNode0.put("JSON", short1);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory0);
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[3];
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
deserializationFeatureArray0[1] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
// Undeclared exception!
try {
objectReader1._reportUndetectableSource((Object) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test323() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
ObjectReader objectReader1 = objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader1.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader2 = objectMapper0.reader(deserializationFeature1);
objectReaderArray0[0] = objectReader2;
objectReaderArray0[1] = objectReader1;
objectReaderArray0[2] = objectReader1;
objectReaderArray0[3] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapType> class1 = MapType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class1);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
dataFormatReaders2.withOptimalMatch(matchStrength0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)29;
byteArray0[1] = (byte) (-92);
MatchStrength matchStrength1 = MatchStrength.FULL_MATCH;
dataFormatReaders0.withOptimalMatch(matchStrength1);
byteArray0[2] = (byte) (-92);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders1.findFormat(byteArray0);
objectReader1.forType(class1);
// Undeclared exception!
try {
objectReader1._detectBindAndClose(dataFormatReaders_Match0, false);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test324() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
objectReader0.withFormatDetection(objectReaderArray0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)121;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 0, 0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader0._findRootDeserializer(defaultDeserializationContext0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test325() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
ObjectReader objectReader0 = objectMapper0.reader();
byte[] byteArray0 = new byte[12];
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
StringBuilder stringBuilder0 = new StringBuilder((CharSequence) "JSON");
simpleType0.getGenericSignature(stringBuilder0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
// Undeclared exception!
try {
objectReader0._findRootDeserializer(defaultDeserializationContext0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test326() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)20;
byteArray0[2] = (byte)124;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)0;
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
FormatFeature[] formatFeatureArray0 = new FormatFeature[4];
JsonWriteFeature jsonWriteFeature0 = JsonWriteFeature.WRITE_NAN_AS_STRINGS;
formatFeatureArray0[0] = (FormatFeature) jsonWriteFeature0;
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_JAVA_COMMENTS;
formatFeatureArray0[1] = (FormatFeature) jsonReadFeature0;
JsonReadFeature jsonReadFeature1 = JsonReadFeature.ALLOW_JAVA_COMMENTS;
formatFeatureArray0[2] = (FormatFeature) jsonReadFeature1;
JsonWriteFeature jsonWriteFeature1 = JsonWriteFeature.ESCAPE_NON_ASCII;
formatFeatureArray0[3] = (FormatFeature) jsonWriteFeature1;
ObjectReader objectReader1 = objectReader0.withFeatures(formatFeatureArray0);
assertNotSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test327() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
PipedReader pipedReader0 = new PipedReader();
byte[] byteArray0 = new byte[0];
ObjectReader objectReader0 = objectMapper0.reader();
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
ObjectReader objectReader1 = objectReader0.withValueToUpdate(byteArrayInputStream0);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test328() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)1;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
JsonFactory jsonFactory0 = new JsonFactory();
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1);
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
ObjectReader objectReader0 = objectMapper1.reader((InjectableValues) injectableValues_Std0);
// Undeclared exception!
try {
objectReader0.readValues((DataInput) dataInputStream0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test329() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
ObjectReader objectReader0 = objectMapper0.reader();
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
objectMapper0.readerFor(class0);
objectReader0.withRootName("8:");
Object object0 = new Object();
HashSet<String> hashSet0 = new HashSet<String>();
BuilderBasedDeserializer builderBasedDeserializer0 = null;
try {
builderBasedDeserializer0 = new BuilderBasedDeserializer((BuilderBasedDeserializer) null, hashSet0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.BeanDeserializerBase", e);
}
}
@Test(timeout = 4000)
public void test330() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
byte[] byteArray0 = new byte[1];
jsonFactory2.createParser("JSON");
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2);
ObjectMapper objectMapper2 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
ObjectReader objectReader1 = objectMapper2.reader();
objectReader1.with(jsonFactory1);
try {
objectReader0.readValues(byteArray0);
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: (byte[])\"\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test331() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader((FormatSchema) null);
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, true);
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonGenerator_Feature1);
JsonGenerator.Feature jsonGenerator_Feature2 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory4 = jsonFactory3.enable(jsonGenerator_Feature2);
jsonFactory4.disable(jsonGenerator_Feature1);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte) (-57);
byteArray0[1] = (byte) (-57);
// Undeclared exception!
try {
objectReader0.readValue(byteArray0, (int) (-57), 1);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -57
//
verifyException("com.fasterxml.jackson.core.json.UTF8StreamJsonParser", e);
}
}
@Test(timeout = 4000)
public void test332() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonGenerator_Feature0);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.QUOTE_FIELD_NAMES;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonGenerator_Feature1);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2);
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
ObjectReader objectReader0 = objectMapper1.reader((InjectableValues) injectableValues_Std0);
try {
objectReader0.readValues((DataInput) dataInputStream0);
fail("Expecting exception: EOFException");
} catch(EOFException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.DataInputStream", e);
}
}
@Test(timeout = 4000)
public void test333() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
BufferRecycler bufferRecycler1 = jsonFactory1._getBufferRecycler();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler1, 0);
ArrayNode arrayNode0 = new ArrayNode(jsonNodeFactory0, 0);
ObjectNode objectNode0 = arrayNode0.insertObject(1);
Short short0 = new Short((short)0);
ObjectNode objectNode1 = objectNode0.put("Cannot access contents of TextNode as binary due to broken Base64 encoding: %s", short0);
// Undeclared exception!
try {
objectReader0.readValue((JsonNode) objectNode1);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test334() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
MockURL.getFileExample();
PipedInputStream pipedInputStream0 = new PipedInputStream();
MockFile mockFile0 = new MockFile("");
try {
objectReader0._inputStream(mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test335() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
jsonNodeFactory0.numberNode(144);
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
deserializationFeatureArray0[0] = deserializationFeature1;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
byte[] byteArray1 = new byte[1];
byteArray1[0] = (byte)3;
File file0 = MockFile.createTempFile("JSON", "");
MockFile mockFile0 = new MockFile(file0, "");
InputStream inputStream0 = objectReader0._inputStream(mockFile0);
assertEquals(0, inputStream0.available());
}
@Test(timeout = 4000)
public void test336() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
jsonNodeFactory0.numberNode(144);
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
deserializationFeatureArray0[0] = deserializationFeature1;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
byte[] byteArray1 = new byte[1];
byteArray1[0] = (byte)3;
int int0 = (-2225);
int int1 = 726;
File file0 = MockFile.createTempFile("JSON", "");
MockFile mockFile0 = new MockFile(file0, "JSON");
try {
objectReader0._inputStream(mockFile0);
fail("Expecting exception: FileNotFoundException");
} catch(FileNotFoundException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.evosuite.runtime.mock.java.io.MockFileInputStream", e);
}
}
@Test(timeout = 4000)
public void test337() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
LongNode longNode0 = LongNode.valueOf((-9223372036854775808L));
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
ObjectReader objectReader0 = objectMapper0.readerForUpdating(longNode0);
objectReader0.createObjectNode();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory1 = jsonFactory0.enable(jsonGenerator_Feature0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)1;
BufferedInputStream bufferedInputStream0 = new BufferedInputStream((InputStream) null, 1);
DataInputStream dataInputStream0 = new DataInputStream(bufferedInputStream0);
try {
jsonFactory1.createParser((InputStream) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Stream closed
//
verifyException("java.io.BufferedInputStream", e);
}
}
@Test(timeout = 4000)
public void test338() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-92);
byteArray0[1] = (byte)111;
byteArray0[2] = (byte) (-44);
byteArray0[3] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType.constructUnsafe(class0);
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
objectReaderArray0[0] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
defaultDeserializationContext_Impl0.getConfig();
// Undeclared exception!
try {
dataFormatReaders0.with((DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test339() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
JsonFactory jsonFactory1 = jsonFactory0.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[8];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
objectReaderArray0[4] = objectReader0;
objectReaderArray0[5] = objectReader0;
objectReaderArray0[6] = objectReader0;
objectReaderArray0[7] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
MatchStrength matchStrength0 = MatchStrength.SOLID_MATCH;
dataFormatReaders0.withMinimalMatch(matchStrength0);
MatchStrength matchStrength1 = MatchStrength.WEAK_MATCH;
dataFormatReaders1.withOptimalMatch(matchStrength1);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)69;
byteArray0[1] = (byte) (-22);
dataFormatReaders1.findFormat(byteArray0);
try {
objectReader0.readValue(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected end-of-input in null
// at [Source: (byte[])\"E\uFFFD\"; line: 1, column: 5]
//
verifyException("com.fasterxml.jackson.core.base.ParserMinimalBase", e);
}
}
@Test(timeout = 4000)
public void test340() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
byte[] byteArray0 = new byte[0];
arrayNode0.binaryNode(byteArray0);
objectReader0.withType((Type) class0);
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
objectMapper0.reader(deserializationFeature0);
ArrayNode arrayNode1 = jsonNodeFactory0.arrayNode();
objectReader0.treeAsTokens(arrayNode1);
Object object0 = new Object();
}
@Test(timeout = 4000)
public void test341() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<DeserializationConfig> class0 = DeserializationConfig.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
dataFormatReaders0.withType(simpleType0);
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
objectMapper0.reader(deserializationFeature1);
objectReader0.with((JsonNodeFactory) null);
System.setCurrentTimeMillis((-1L));
ObjectReader objectReader1 = objectMapper0.readerFor((JavaType) simpleType0);
PipedReader pipedReader0 = new PipedReader();
try {
objectReader1.readValues((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test342() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
StringReader stringReader0 = new StringReader(" entries");
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte) (-95);
byteArray0[1] = (byte) (-104);
byteArray0[2] = (byte)0;
byteArray0[3] = (byte)2;
byteArray0[4] = (byte) (-83);
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectMapper0, charsToNameCanonicalizer0);
readerBasedJsonParser0.getSchema();
ObjectReader objectReader0 = objectMapper1.reader((FormatSchema) null);
ObjectReader objectReader1 = objectReader0.withoutRootName();
// Undeclared exception!
try {
objectReader1.readValues((JsonParser) readerBasedJsonParser0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test343() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(false);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType.constructUnsafe(class0);
int int0 = 0;
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.INCONCLUSIVE;
dataFormatReaders1.withOptimalMatch(matchStrength0);
MatchStrength matchStrength1 = MatchStrength.WEAK_MATCH;
dataFormatReaders1.withMinimalMatch(matchStrength1);
objectReader0._verifySchemaType((FormatSchema) null);
PipedReader pipedReader0 = new PipedReader();
try {
objectReader0.readValue((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test344() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, true);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature1);
jsonFactory2.disable(jsonGenerator_Feature1);
JsonParser jsonParser0 = jsonFactory2.createNonBlockingByteArrayParser();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
ObjectReader objectReader0 = objectMapper0.reader();
objectReader0.with(jsonFactory1);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
objectReader0._considerFilter(jsonParser0, true);
byteArray0[1] = (byte) (-109);
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)107;
byteArray0[4] = (byte)0;
FileSystemHandling.shouldAllThrowIOExceptions();
byteArray0[5] = (byte)0;
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 147)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\u0000\uFFFD\u0001k\u0000\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test345() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
byte[] byteArray0 = new byte[0];
// Undeclared exception!
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test346() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType.constructUnsafe(class0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.INCONCLUSIVE;
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMinimalMatch(matchStrength0);
dataFormatReaders2.withOptimalMatch((MatchStrength) null);
byte[] byteArray0 = new byte[0];
dataFormatReaders1.findFormat(byteArray0);
// Undeclared exception!
try {
objectReader0.readValue(byteArray0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test347() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper0);
ObjectReader objectReader0 = objectMapper0.reader();
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
BeanDeserializerFactory beanDeserializerFactory1 = new BeanDeserializerFactory(deserializerFactoryConfig0);
BeanDeserializerFactory beanDeserializerFactory2 = new BeanDeserializerFactory(deserializerFactoryConfig0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
deserializerFactoryConfig0.withDeserializerModifier(beanDeserializerModifier0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-95);
byteArray0[2] = (byte)0;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)17;
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: CharConversionException");
} catch(CharConversionException e) {
//
// Unsupported UCS-4 endianness (3412) detected
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test348() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-92);
byteArray0[1] = (byte)111;
byteArray0[2] = (byte) (-44);
byteArray0[3] = (byte) (-49);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
DataInputStream dataInputStream0 = new DataInputStream(byteArrayInputStream0);
try {
objectReader0.readValues((DataInput) dataInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Invalid UTF-8 start byte 0xa4
// at [Source: (DataInputStream); line: 1, column: -1]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test349() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, true);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature1);
jsonFactory2.disable(jsonGenerator_Feature1);
jsonFactory2.createNonBlockingByteArrayParser();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
ObjectReader objectReader0 = objectMapper0.reader();
objectReader0.with(jsonFactory1);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-109);
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)107;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte)0;
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 147)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\u0000\uFFFD\u0001k\u0000\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test350() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
ObjectReader objectReader0 = objectMapper0.reader();
byte[] byteArray0 = new byte[12];
ObjectReader[] objectReaderArray0 = new ObjectReader[10];
objectReaderArray0[0] = objectReader0;
DateFormat dateFormat0 = MockDateFormat.getDateInstance();
objectMapper0.setDateFormat(dateFormat0);
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader0;
objectReaderArray0[3] = objectReader0;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
ObjectReader objectReader1 = objectReader0.withValueToUpdate(jsonFactory2);
objectReader0.createArrayNode();
assertNotSame(objectReader0, objectReader1);
}
@Test(timeout = 4000)
public void test351() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
objectReader0.createArrayNode();
PipedReader pipedReader0 = new PipedReader();
try {
objectReader0.readValues((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test352() throws Throwable {
FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "Q7[R&=ZWyxzus8*A.K");
JsonFactory jsonFactory0 = new JsonFactory();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl1.copy();
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-53);
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)36;
byteArray0[4] = (byte) (-42);
byteArray0[5] = (byte)1;
byteArray0[6] = (byte) (-8);
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider0, (DefaultDeserializationContext) null);
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
ContextAttributes contextAttributes1 = contextAttributes0.withoutSharedAttribute(defaultSerializerProvider_Impl0);
ObjectReader objectReader0 = objectMapper0.reader(contextAttributes1);
// Undeclared exception!
try {
objectReader0.readValues(byteArray0, 4000, (int) 0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test353() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
dataFormatReaders2.withMinimalMatch(matchStrength0);
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
ShortNode shortNode0 = new ShortNode((short)3);
contextAttributes0.withoutSharedAttribute(shortNode0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
ObjectReader objectReader1 = objectMapper1.reader(contextAttributes0);
objectReader1._verifySchemaType((FormatSchema) null);
PipedReader pipedReader0 = new PipedReader();
try {
objectReader1.readValue((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test354() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
Class<MapperFeature> class0 = MapperFeature.class;
ObjectReader objectReader0 = objectMapper1.readerFor(class0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-76);
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)0;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)3;
byteArray0[5] = (byte) (-15);
byteArray0[6] = (byte) (-61);
byteArray0[7] = (byte)45;
// Undeclared exception!
try {
objectReader0.readValues(byteArray0, (-2024), 3370);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -2024
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test355() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
objectMapper0.defaultClassIntrospector();
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
byte[] byteArray0 = new byte[2];
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
JsonFactory jsonFactory2 = jsonFactory1.setCodec(objectReader1);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory3 = jsonFactory2.configure(jsonGenerator_Feature0, false);
JsonFactory jsonFactory4 = jsonFactory3.copy();
objectReader1._new(objectReader0, jsonFactory4);
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-1);
// Undeclared exception!
try {
objectReader1.readValues(byteArray0, (int) 0, (int) 0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test356() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0, deserializationFeatureArray0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
deserializerFactoryConfig0.withDeserializerModifier(beanDeserializerModifier0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-19);
byte byte0 = (byte)118;
byteArray0[2] = (byte)118;
byteArray0[3] = (byte)2;
byteArray0[4] = (byte)70;
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
byteArray0[5] = (byte)1;
// Undeclared exception!
try {
objectReader1.readValues(byteArray0, 1997, (int) 70);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// 1997
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test357() throws Throwable {
FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
JsonFactory jsonFactory0 = new JsonFactory();
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonParser_Feature0, false);
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonParser_Feature0);
JsonFactory.builder();
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.STRICT_DUPLICATE_DETECTION;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonGenerator_Feature0);
ObjectReader objectReader0 = null;
try {
objectReader0 = new ObjectReader((ObjectReader) null, jsonFactory3);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test358() throws Throwable {
ObjectReader objectReader0 = null;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = null;
try {
objectReader1 = new ObjectReader((ObjectReader) null, tokenFilter0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test359() throws Throwable {
FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "Q7[R&=ZWyxzus8*A.K");
JsonFactory jsonFactory0 = new JsonFactory();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl1.copy();
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-53);
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)36;
byteArray0[4] = (byte) (-42);
byteArray0[5] = (byte)1;
byteArray0[6] = (byte) (-8);
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider0, (DefaultDeserializationContext) null);
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
ContextAttributes contextAttributes1 = contextAttributes0.withoutSharedAttribute(defaultSerializerProvider_Impl0);
ObjectReader objectReader0 = objectMapper0.reader(contextAttributes1);
objectReader0._verifySchemaType((FormatSchema) null);
}
@Test(timeout = 4000)
public void test360() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSuperClass();
ObjectReader objectReader1 = objectReader0.withType((JavaType) null);
JsonWriteFeature jsonWriteFeature0 = JsonWriteFeature.QUOTE_FIELD_NAMES;
objectReader1.with((FormatFeature) jsonWriteFeature0);
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) null, (JavaType) resolvedRecursiveType0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test361() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader();
// Undeclared exception!
try {
objectReader0.readValues((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test362() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0, deserializationFeatureArray0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
deserializerFactoryConfig0.withDeserializerModifier(beanDeserializerModifier0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-19);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
ObjectReader[] objectReaderArray0 = new ObjectReader[3];
objectReaderArray0[0] = objectReader0;
objectReaderArray0[1] = objectReader0;
objectReaderArray0[2] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
TypeReference<MapType> typeReference0 = (TypeReference<MapType>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.forType(typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test363() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
objectReader0.withFormatDetection((ObjectReader[]) null);
ObjectIdGenerators.IntSequenceGenerator objectIdGenerators_IntSequenceGenerator0 = new ObjectIdGenerators.IntSequenceGenerator();
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) null, (TypeReference<ArrayNode>) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test364() throws Throwable {
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
byte[] byteArray0 = new byte[1];
ObjectMapper objectMapper0 = new ObjectMapper();
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
TypeReference<IntNode> typeReference0 = (TypeReference<IntNode>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.readValues((JsonParser) null, typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test365() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonParser_Feature0);
JsonFactory jsonFactory3 = jsonFactory2.setCodec(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory3);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
objectMapper1.reader(jsonNodeFactory0);
byte byte0 = (byte) (-116);
ObjectReader objectReader0 = objectMapper1.reader();
// Undeclared exception!
try {
objectReader0.readValues((byte[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test366() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
// Undeclared exception!
try {
objectReader0.readValue((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.JsonFactory", e);
}
}
@Test(timeout = 4000)
public void test367() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
jsonNodeFactory0.arrayNode();
String string0 = "v";
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-57);
byteArray0[1] = (byte) (-57);
byteArray0[2] = (byte) (-57);
byteArray0[3] = (byte) (-57);
FileSystemHandling.shouldAllThrowIOExceptions();
byteArray0[4] = (byte) (-57);
byteArray0[5] = (byte) (-57);
byteArray0[6] = (byte) (-57);
byteArray0[7] = (byte) (-57);
// Undeclared exception!
try {
objectReader1.readValue(byteArray0, (int) (-57), 69);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// -57
//
verifyException("com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper", e);
}
}
@Test(timeout = 4000)
public void test368() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
// Undeclared exception!
try {
objectReader0.readValue("");
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test369() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
JsonFactory jsonFactory1 = jsonFactory0.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.copy();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory1, defaultSerializerProvider_Impl0, defaultDeserializationContext0);
Class<ArrayNode> class0 = ArrayNode.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
// Undeclared exception!
try {
objectReader0.treeAsTokens((TreeNode) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.node.TreeTraversingParser", e);
}
}
@Test(timeout = 4000)
public void test370() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
ObjectReader objectReader1 = objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader1.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader2 = objectMapper0.reader(deserializationFeature1);
objectReaderArray0[0] = objectReader2;
objectReaderArray0[1] = objectReader1;
objectReaderArray0[2] = objectReader1;
objectReaderArray0[3] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapType> class1 = MapType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class1);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(64);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
dataFormatReaders2.withOptimalMatch(matchStrength0);
byte[] byteArray0 = new byte[3];
dataFormatReaders1.findFormat(byteArray0);
try {
objectReader2.readValue(byteArray0);
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: (byte[])\"\u0000\u0000\u0000\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test371() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
ObjectReader objectReader1 = objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
jsonNodeFactory0.arrayNode();
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
objectMapper0.reader(deserializationFeature0);
objectReaderArray0[0] = objectReader1;
objectReaderArray0[2] = objectReader1;
objectReaderArray0[3] = objectReader1;
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
objectReader1.without(jsonParser_Feature0);
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapType> class1 = MapType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class1);
// Undeclared exception!
try {
dataFormatReaders0.withType(simpleType0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test372() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
// Undeclared exception!
try {
objectReader0.readValues("");
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test373() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[0];
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
ObjectReader objectReader1 = objectReader0.withFeatures(deserializationFeatureArray0);
assertSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test374() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSelfReferencedType();
ConcurrentHashMap<String, Object> concurrentHashMap0 = new ConcurrentHashMap<String, Object>();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(concurrentHashMap0);
Class<SimpleType> class1 = SimpleType.class;
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class1, (Object) objectReader0);
objectReader0.with((InjectableValues) injectableValues_Std1);
ObjectReader objectReader1 = objectReader0.withType((JavaType) null);
// Undeclared exception!
try {
objectReader1.readValue((JsonParser) null, (JavaType) resolvedRecursiveType0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test375() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
try {
objectReader0.readValue("fromString");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'fromString': was expecting 'null', 'true', 'false' or NaN
// at [Source: (String)\"fromString\"; line: 1, column: 21]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test376() throws Throwable {
FileSystemHandling.shouldAllThrowIOExceptions();
JsonFactory jsonFactory0 = new JsonFactory();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl1, defaultDeserializationContext_Impl0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
ContextAttributes contextAttributes0 = ContextAttributes.Impl.getEmpty();
ObjectReader objectReader0 = objectMapper1.reader(contextAttributes0);
DeserializationConfig deserializationConfig0 = objectReader0.getConfig();
assertEquals(0, deserializationConfig0.mixInCount());
}
@Test(timeout = 4000)
public void test377() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0, deserializationFeatureArray0);
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
ObjectReader objectReader1 = objectReader0.withHandler(deserializationProblemHandler0);
assertNotSame(objectReader1, objectReader0);
}
@Test(timeout = 4000)
public void test378() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
PipedInputStream pipedInputStream0 = new PipedInputStream();
Vector<IntNode> vector0 = new Vector<IntNode>();
objectMapper0.updateValue((Collection<IntNode>) vector0, (Object) vector0);
HashMap<ArrayType, SettableBeanProperty> hashMap0 = new HashMap<ArrayType, SettableBeanProperty>();
String string0 = "\":PI:Y6*POR";
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
objectReader0.withHandler((DeserializationProblemHandler) null);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
JsonFormatVisitorWrapper.Base jsonFormatVisitorWrapper_Base0 = new JsonFormatVisitorWrapper.Base(defaultSerializerProvider_Impl1);
// Undeclared exception!
try {
objectMapper0.acceptJsonFormatVisitor((JavaType) null, (JsonFormatVisitorWrapper) jsonFormatVisitorWrapper_Base0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// type must be provided
//
verifyException("com.fasterxml.jackson.databind.ObjectMapper", e);
}
}
@Test(timeout = 4000)
public void test379() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0, deserializationFeatureArray0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
objectReader1._initForMultiRead(defaultDeserializationContext0, (JsonParser) null);
assertFalse(defaultDeserializationContext_Impl0.equals((Object)defaultDeserializationContext0));
// Undeclared exception!
try {
objectReader1.readValue((JsonParser) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test380() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
try {
objectReader1.readValues("v");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'v': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"v\"; line: 1, column: 3]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test381() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader(deserializationFeature0, deserializationFeatureArray0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
deserializerFactoryConfig0.withDeserializerModifier(beanDeserializerModifier0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-19);
byteArray0[2] = (byte)118;
byteArray0[3] = (byte)2;
byteArray0[4] = (byte)70;
byteArray0[5] = (byte)1;
try {
objectReader1.readValues(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '\u00ED\u7602\u4601': was expecting ('true', 'false' or 'null')
// at [Source: (byte[])\"\u0000\uFFFDv\u0002F\u0001\"; line: 1, column: 7]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test382() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "JSON");
deserializationFeatureArray0[0] = deserializationFeature0;
ObjectReader objectReader0 = objectMapper1.reader();
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)0;
byteArray0[3] = (byte)0;
try {
objectReader1.readValue("JSON");
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'JSON': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"JSON\"; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test383() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
PropertyAccessor propertyAccessor0 = PropertyAccessor.ALL;
JsonAutoDetect.Visibility jsonAutoDetect_Visibility0 = JsonAutoDetect.Visibility.NONE;
ObjectMapper objectMapper1 = objectMapper0.setVisibility(propertyAccessor0, jsonAutoDetect_Visibility0);
HashMap<String, Object> hashMap0 = new HashMap<String, Object>();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(hashMap0);
Class<BooleanNode> class0 = BooleanNode.class;
CoreXMLDeserializers.Std coreXMLDeserializers_Std0 = new CoreXMLDeserializers.Std(class0, 1);
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class0, (Object) coreXMLDeserializers_Std0);
ObjectReader objectReader0 = objectMapper1.reader((InjectableValues) injectableValues_Std1);
PipedInputStream pipedInputStream0 = new PipedInputStream(1);
try {
objectReader0.readTree((InputStream) pipedInputStream0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedInputStream", e);
}
}
@Test(timeout = 4000)
public void test384() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_ENUMS_USING_TO_STRING;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[1];
DeserializationFeature deserializationFeature1 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
deserializationFeatureArray0[0] = deserializationFeature1;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
byte[] byteArray1 = new byte[1];
byteArray1[0] = (byte)3;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray1, (-2225), 726);
// Undeclared exception!
try {
objectReader0.readTree((InputStream) byteArrayInputStream0);
fail("Expecting exception: ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("java.io.ByteArrayInputStream", e);
}
}
@Test(timeout = 4000)
public void test385() throws Throwable {
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte) (-120);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
byteArray0[6] = (byte)5;
byteArray0[7] = (byte)3;
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.IGNORE_UNDEFINED;
boolean boolean1 = objectReader0.isEnabled(jsonParser_Feature0);
assertTrue(boolean1 == boolean0);
}
@Test(timeout = 4000)
public void test386() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
PropertyAccessor propertyAccessor0 = PropertyAccessor.CREATOR;
JsonAutoDetect.Visibility jsonAutoDetect_Visibility0 = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC;
ObjectMapper objectMapper1 = objectMapper0.setVisibility(propertyAccessor0, jsonAutoDetect_Visibility0);
deserializationFeatureArray0[3] = deserializationFeature1;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = objectMapper1.reader(deserializationFeature0);
ObjectReader objectReader2 = new ObjectReader(objectReader1, tokenFilter0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withConfig(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
defaultDeserializationContext_Impl0.with(deserializerFactory0);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
objectReader0._initForMultiRead(defaultDeserializationContext_Impl0, (JsonParser) null);
Class<Object> class0 = Object.class;
ObjectReader objectReader3 = objectReader0.withView(class0);
assertNotSame(objectReader3, objectReader0);
}
@Test(timeout = 4000)
public void test387() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
boolean boolean0 = true;
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
dataFormatReaders2.withMinimalMatch(matchStrength0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-92);
int int0 = 5469;
int int1 = 433;
StringReader stringReader0 = new StringReader("$Zu1");
try {
objectReader0.readValue((Reader) stringReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token '$Zu1': was expecting ('true', 'false' or 'null')
// at [Source: (StringReader); line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test388() throws Throwable {
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl0.copy();
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.with(beanDeserializerFactory0);
ObjectMapper objectMapper0 = new ObjectMapper((JsonFactory) null, defaultSerializerProvider0, defaultDeserializationContext0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
objectReaderArray0[0] = objectReader0;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
objectReaderArray0[1] = objectReader1;
TypeFactory typeFactory0 = objectReader1.getTypeFactory();
assertNotNull(typeFactory0);
}
@Test(timeout = 4000)
public void test389() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
PropertyAccessor propertyAccessor0 = PropertyAccessor.CREATOR;
JsonAutoDetect.Visibility jsonAutoDetect_Visibility0 = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC;
objectMapper0.setVisibility(propertyAccessor0, jsonAutoDetect_Visibility0);
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSelfReferencedType();
objectReader0.withType((JavaType) null);
JsonParser jsonParser0 = null;
TypeReference<PlaceholderForType> typeReference0 = (TypeReference<PlaceholderForType>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn(class0).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) null, typeReference0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test390() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
objectMapper0.reader(deserializationFeature0);
ArrayNode arrayNode1 = jsonNodeFactory0.arrayNode();
objectReader0.treeAsTokens(arrayNode1);
Object object0 = new Object();
HashSet<String> hashSet0 = new HashSet<String>();
BuilderBasedDeserializer builderBasedDeserializer0 = null;
try {
builderBasedDeserializer0 = new BuilderBasedDeserializer((BuilderBasedDeserializer) null, hashSet0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.BeanDeserializerBase", e);
}
}
@Test(timeout = 4000)
public void test391() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte) (-120);
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
objectReader0.treeAsTokens(arrayNode0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
BeanDeserializerModifier beanDeserializerModifier0 = mock(BeanDeserializerModifier.class, new ViolatedAssumptionAnswer());
DeserializerFactory deserializerFactory0 = beanDeserializerFactory0.withDeserializerModifier(beanDeserializerModifier0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(deserializerFactory0);
Object object0 = new Object();
// Undeclared exception!
try {
defaultDeserializationContext_Impl0.setAttribute(object0, objectMapper2);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test392() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSelfReferencedType();
ObjectReader objectReader1 = objectReader0.withType((JavaType) null);
JsonParser jsonParser0 = null;
TypeReference<PlaceholderForType> typeReference0 = (TypeReference<PlaceholderForType>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Class<SimpleType> class1 = SimpleType.class;
objectReader1.withType(class1);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
// Undeclared exception!
try {
defaultDeserializationContext_Impl0.getAnnotationIntrospector();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test(timeout = 4000)
public void test393() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
byte[] byteArray0 = new byte[1];
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
BooleanNode booleanNode0 = BooleanNode.valueOf(true);
IOContext iOContext0 = new IOContext(bufferRecycler0, booleanNode0, true);
StringReader stringReader0 = new StringReader(" entries");
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ObjectReader objectReader0 = objectMapper0.readerForUpdating(" entries");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectReader0, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'w';
FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
charArray0[1] = '/';
charArray0[2] = 'l';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectMapper0, charsToNameCanonicalizer0, charArray0, (byte) (-49), 1257, false);
readerBasedJsonParser1.getSchema();
JsonFactory jsonFactory0 = new JsonFactory();
JsonFactory jsonFactory1 = jsonFactory0.setCodec(objectMapper0);
JsonFactory jsonFactory2 = jsonFactory1.setRootValueSeparator("JSON");
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER;
jsonFactory2.enable(jsonParser_Feature0);
ObjectReader objectReader1 = objectReader0.withoutRootName();
objectReader0.readValues((JsonParser) readerBasedJsonParser1);
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader2 = objectReader1.withType(class0);
assertNotSame(objectReader0, objectReader1);
assertNotSame(objectReader2, objectReader1);
}
@Test(timeout = 4000)
public void test394() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
objectReader0.withType((JavaType) resolvedRecursiveType0);
JsonParser jsonParser0 = null;
AnnotatedField annotatedField0 = new AnnotatedField((TypeResolutionContext) null, (Field) null, (AnnotationMap) null);
// Undeclared exception!
try {
annotatedField0.getRawType();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.introspect.AnnotatedField", e);
}
}
@Test(timeout = 4000)
public void test395() throws Throwable {
FileSystemHandling.createFolder((EvoSuiteFile) null);
FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
JsonpCharacterEscapes jsonpCharacterEscapes0 = new JsonpCharacterEscapes();
JsonFactory jsonFactory1 = jsonFactory0.setCharacterEscapes(jsonpCharacterEscapes0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonGenerator_Feature0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl1, defaultDeserializationContext_Impl0);
ObjectReader objectReader0 = objectMapper1.readerForUpdating("");
// Undeclared exception!
try {
objectReader0._new((ObjectReader) null, jsonFactory0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test396() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader((FormatSchema) null);
JsonFactory jsonFactory0 = new JsonFactory(objectReader0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT;
JsonFactory jsonFactory1 = jsonFactory0.configure(jsonGenerator_Feature0, true);
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
JsonGenerator.Feature jsonGenerator_Feature1 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory3 = jsonFactory2.enable(jsonGenerator_Feature1);
JsonGenerator.Feature jsonGenerator_Feature2 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory4 = jsonFactory3.enable(jsonGenerator_Feature2);
jsonFactory4.disable(jsonGenerator_Feature1);
jsonFactory1.createNonBlockingByteArrayParser();
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
objectMapper1.reader();
objectReader0.with(jsonFactory2);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)1;
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Illegal character ((CTRL-CHAR, code 1)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// at [Source: (byte[])\"\u0001\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test397() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
ObjectMapper objectMapper1 = new ObjectMapper();
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonFactory jsonFactory0 = new JsonFactory(objectMapper2);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonParser_Feature0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN;
JsonFactory jsonFactory2 = jsonFactory1.disable(jsonGenerator_Feature0);
// Undeclared exception!
try {
objectReader0._new((ObjectReader) null, jsonFactory2);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test398() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
SimpleDeserializers simpleDeserializers0 = new SimpleDeserializers();
deserializerFactoryConfig0.withAdditionalDeserializers(simpleDeserializers0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl1, defaultDeserializationContext_Impl0);
Class<Integer> class0 = Integer.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, jsonFactory0);
int int0 = 2217;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
DataOutputStream dataOutputStream0 = new DataOutputStream(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = null;
try {
uTF8JsonGenerator0 = new UTF8JsonGenerator((IOContext) null, 2217, objectReader1, dataOutputStream0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
}
}
@Test(timeout = 4000)
public void test399() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<CollectionType> class0 = CollectionType.class;
ObjectReader objectReader0 = objectMapper0.readerFor(class0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_INVALID_SUBTYPE;
FormatFeature[] formatFeatureArray0 = new FormatFeature[1];
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES;
formatFeatureArray0[0] = (FormatFeature) jsonReadFeature0;
objectReader0.withoutFeatures(formatFeatureArray0);
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[0];
ObjectReader objectReader1 = objectReader0.without(deserializationFeature0, deserializationFeatureArray0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_SINGLE_QUOTES;
ObjectReader objectReader2 = objectReader0.with(jsonParser_Feature0);
assertNotSame(objectReader2, objectReader1);
}
@Test(timeout = 4000)
public void test400() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl1 = new DefaultSerializerProvider.Impl(defaultSerializerProvider_Impl0);
DefaultSerializerProvider defaultSerializerProvider0 = defaultSerializerProvider_Impl1.copy();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
DefaultDeserializationContext defaultDeserializationContext0 = defaultDeserializationContext_Impl0.copy();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider0, defaultDeserializationContext0);
ShortNode shortNode0 = ShortNode.valueOf((short)1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, objectMapper0, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 3, false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
filteringGeneratorDelegate0.getSchema();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
Class<ObjectNode> class0 = ObjectNode.class;
IntNode intNode0 = new IntNode(56319);
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue((Class<?>) class0, (Object) intNode0);
InjectableValues.Std injectableValues_Std2 = injectableValues_Std1.addValue("`r:)W~b7?`i9sKu", (Object) shortNode0);
ObjectReader objectReader0 = null;
try {
objectReader0 = new ObjectReader(objectMapper0, (DeserializationConfig) null, (JavaType) null, shortNode0, (FormatSchema) null, injectableValues_Std2);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test401() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory((ObjectCodec) null);
JsonFactory jsonFactory1 = jsonFactory0.setCodec((ObjectCodec) null);
JsonFactory jsonFactory2 = jsonFactory1.copy();
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2, defaultSerializerProvider_Impl0, (DefaultDeserializationContext) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.ACCEPT_FLOAT_AS_INT;
ObjectReader objectReader0 = objectMapper0.reader(deserializationFeature0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-57);
// Undeclared exception!
try {
objectReader0.readValue(byteArray0, (int) (-57), (-2652));
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.DeserializationContext", e);
}
}
@Test(timeout = 4000)
public void test402() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonFactory jsonFactory0 = new JsonFactory(objectMapper0);
ObjectMapper objectMapper1 = new ObjectMapper(jsonFactory0);
ObjectMapper objectMapper2 = new ObjectMapper(objectMapper1);
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper2.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-118);
byteArray0[1] = (byte)3;
byteArray0[2] = (byte)5;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)0;
byteArray0[5] = (byte) (-120);
byteArray0[6] = (byte)5;
byteArray0[7] = (byte)3;
try {
objectReader0.readValues(byteArray0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unexpected character ((CTRL-CHAR, code 138)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// at [Source: (byte[])\"\uFFFD\u0003\u0005\u0000\u0000\uFFFD\u0005\u0003\"; line: 1, column: 2]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test403() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
DeserializerFactoryConfig deserializerFactoryConfig0 = new DeserializerFactoryConfig();
BeanDeserializerFactory beanDeserializerFactory0 = new BeanDeserializerFactory(deserializerFactoryConfig0);
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
defaultDeserializationContext_Impl0.getConfig();
ObjectReader objectReader0 = null;
try {
objectReader0 = new ObjectReader(objectMapper0, (DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test404() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
ObjectReader objectReader0 = null;
try {
objectReader0 = new ObjectReader(objectMapper1, (DeserializationConfig) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test405() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
defaultDeserializationContext_Impl0.getConfig();
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
Class<DeserializationConfig> class0 = DeserializationConfig.class;
ArrayType arrayType0 = typeFactory0.constructArrayType(class0);
MissingNode missingNode0 = MissingNode.getInstance();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue("h>su \"KH2A", (Object) class0);
// Undeclared exception!
try {
objectMapper0._newReader((DeserializationConfig) null, arrayType0, missingNode0, (FormatSchema) null, injectableValues_Std1);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test406() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
Class<CollectionType> class0 = CollectionType.class;
ObjectReader objectReader0 = objectMapper1.readerWithView(class0);
ObjectReader objectReader1 = new ObjectReader(objectReader0, (TokenFilter) null);
DeserializationFeature deserializationFeature0 = DeserializationFeature.UNWRAP_ROOT_VALUE;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
DeserializationProblemHandler deserializationProblemHandler0 = mock(DeserializationProblemHandler.class, new ViolatedAssumptionAnswer());
objectMapper1.addHandler(deserializationProblemHandler0);
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
objectMapper1.disable(deserializationFeature1);
deserializationFeatureArray0[3] = deserializationFeature0;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
ObjectReader objectReader2 = objectReader1.with(deserializationFeature0, deserializationFeatureArray0);
assertNotSame(objectReader1, objectReader2);
}
@Test(timeout = 4000)
public void test407() throws Throwable {
FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader1 = objectMapper0.reader(deserializationFeature0);
HashMap<String, Object> hashMap0 = new HashMap<String, Object>();
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std(hashMap0);
objectReader1.with((InjectableValues) injectableValues_Std0);
ArrayNode arrayNode1 = jsonNodeFactory0.arrayNode();
objectReader0.treeAsTokens(arrayNode1);
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[2];
deserializationFeatureArray0[0] = deserializationFeature0;
DeserializationFeature deserializationFeature2 = DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS;
deserializationFeatureArray0[1] = deserializationFeature2;
objectReader0.with(deserializationFeature1, deserializationFeatureArray0);
System.setCurrentTimeMillis((-4449L));
}
@Test(timeout = 4000)
public void test408() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
byte[] byteArray0 = null;
// Undeclared exception!
try {
JsonReadFeature.valueOf("Cannot use FormatSchema of type ");
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// No enum constant com.fasterxml.jackson.core.json.JsonReadFeature.Cannot use FormatSchema of type
//
verifyException("java.lang.Enum", e);
}
}
@Test(timeout = 4000)
public void test409() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
// Undeclared exception!
try {
objectReader1.readTree((InputStream) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.deser.DataFormatReaders", e);
}
}
@Test(timeout = 4000)
public void test410() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
Class<FilteringParserDelegate> class0 = FilteringParserDelegate.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
JsonReadFeature jsonReadFeature0 = JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS;
ObjectReader objectReader1 = objectReader0.without((FormatFeature) jsonReadFeature0);
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.instance;
ArrayNode arrayNode0 = jsonNodeFactory0.arrayNode();
arrayNode0.findParent("v");
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader1.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[4];
DeserializationFeature deserializationFeature1 = DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS;
ObjectReader objectReader2 = objectMapper0.reader(deserializationFeature1);
objectReaderArray0[0] = objectReader2;
objectReaderArray0[1] = objectReader1;
objectReaderArray0[2] = objectReader1;
objectReaderArray0[3] = objectReader1;
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapType> class1 = MapType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class1);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
dataFormatReaders2.withOptimalMatch(matchStrength0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)29;
byteArray0[1] = (byte) (-92);
byteArray0[2] = (byte) (-92);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders1.findFormat(byteArray0);
// Undeclared exception!
try {
objectReader1._detectBindAndClose(dataFormatReaders_Match0, false);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test411() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
InjectableValues.Std injectableValues_Std0 = new InjectableValues.Std();
InjectableValues.Std injectableValues_Std1 = injectableValues_Std0.addValue("wy+<5_ t~)", (Object) objectMapper1);
Class<DecimalNode> class0 = DecimalNode.class;
JavaType javaType0 = TypeFactory.unknownType();
MapLikeType mapLikeType0 = MapLikeType.upgradeFrom(javaType0, javaType0, javaType0);
JavaType[] javaTypeArray0 = new JavaType[2];
ArrayType arrayType0 = ArrayType.construct(javaType0, (TypeBindings) null, (Object) null, (Object) null);
ArrayType arrayType1 = arrayType0.withStaticTyping();
ArrayType arrayType2 = arrayType0.withContentValueHandler(javaType0);
MapLikeType mapLikeType1 = mapLikeType0.withValueHandler(arrayType2);
ArrayType arrayType3 = arrayType1.withTypeHandler(mapLikeType1);
ArrayType arrayType4 = arrayType3.withValueHandler(objectMapper0);
Object object0 = new Object();
ArrayType arrayType5 = arrayType4.withContentTypeHandler(object0);
javaTypeArray0[0] = (JavaType) arrayType5;
javaTypeArray0[1] = (JavaType) mapLikeType0;
ReferenceType referenceType0 = ReferenceType.construct((Class<?>) class0, (TypeBindings) null, (JavaType) mapLikeType0, javaTypeArray0, (JavaType) mapLikeType1);
ReferenceType referenceType1 = referenceType0.withStaticTyping();
InjectableValues.Std injectableValues_Std2 = injectableValues_Std1.addValue((Class<?>) class0, (Object) referenceType1);
ObjectReader objectReader0 = objectMapper1.reader((InjectableValues) injectableValues_Std2);
JsonFactory jsonFactory0 = new JsonFactory();
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.ESCAPE_NON_ASCII;
JsonFactory jsonFactory1 = jsonFactory0.disable(jsonGenerator_Feature0);
JsonFactory jsonFactory2 = jsonFactory1.copy();
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_SINGLE_QUOTES;
JsonFactory jsonFactory3 = jsonFactory2.disable(jsonParser_Feature0);
JsonParser jsonParser0 = jsonFactory3.createParser("JSON");
try {
objectReader0.readTree(jsonParser0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Unrecognized token 'JSON': was expecting ('true', 'false' or 'null')
// at [Source: (String)\"JSON\"; line: 1, column: 9]
//
verifyException("com.fasterxml.jackson.core.JsonParser", e);
}
}
@Test(timeout = 4000)
public void test412() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
objectMapper0.defaultClassIntrospector();
ObjectReader[] objectReaderArray0 = new ObjectReader[1];
ObjectReader objectReader1 = objectReader0.withFormatDetection(objectReaderArray0);
MockFile mockFile0 = new MockFile("\":PI:Y6*POR");
ObjectIdGenerators.IntSequenceGenerator objectIdGenerators_IntSequenceGenerator0 = new ObjectIdGenerators.IntSequenceGenerator();
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, tokenFilter0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedReader pipedReader0 = new PipedReader();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, pipedReader0, objectReader1, charsToNameCanonicalizer0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_MISSING_VALUES;
JsonParser jsonParser0 = readerBasedJsonParser0.disable(jsonParser_Feature0);
// Undeclared exception!
try {
objectReader0.readValue(jsonParser0, (TypeReference<MapperFeature>) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test413() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
DeserializationFeature deserializationFeature0 = DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
DeserializationFeature[] deserializationFeatureArray0 = new DeserializationFeature[7];
deserializationFeatureArray0[0] = deserializationFeature0;
deserializationFeatureArray0[1] = deserializationFeature0;
deserializationFeatureArray0[2] = deserializationFeature0;
DeserializationFeature deserializationFeature1 = DeserializationFeature.USE_LONG_FOR_INTS;
deserializationFeatureArray0[3] = deserializationFeature1;
deserializationFeatureArray0[4] = deserializationFeature0;
deserializationFeatureArray0[5] = deserializationFeature0;
deserializationFeatureArray0[6] = deserializationFeature0;
objectMapper0.disable(deserializationFeature0, deserializationFeatureArray0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSelfReferencedType();
objectReader0.withType((JavaType) null);
JsonParser jsonParser0 = null;
TypeReference<PlaceholderForType> typeReference0 = (TypeReference<PlaceholderForType>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
doReturn((Type) null).when(typeReference0).getType();
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) null, typeReference0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Unrecognized Type: [null]
//
verifyException("com.fasterxml.jackson.databind.type.TypeFactory", e);
}
}
@Test(timeout = 4000)
public void test414() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectReader objectReader0 = objectMapper0.reader();
PropertyAccessor propertyAccessor0 = PropertyAccessor.CREATOR;
JsonAutoDetect.Visibility jsonAutoDetect_Visibility0 = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC;
objectMapper0.setVisibility(propertyAccessor0, jsonAutoDetect_Visibility0);
objectReader0.readTree((InputStream) null);
Class<Integer> class0 = Integer.class;
ResolvedRecursiveType resolvedRecursiveType0 = new ResolvedRecursiveType(class0, (TypeBindings) null);
resolvedRecursiveType0.getSelfReferencedType();
objectReader0.withType((JavaType) null);
// Undeclared exception!
try {
objectReader0.readValue((JsonParser) null, (JavaType) resolvedRecursiveType0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test415() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
DefaultSerializerProvider.Impl defaultSerializerProvider_Impl0 = new DefaultSerializerProvider.Impl();
BeanDeserializerFactory beanDeserializerFactory0 = BeanDeserializerFactory.instance;
DefaultDeserializationContext.Impl defaultDeserializationContext_Impl0 = new DefaultDeserializationContext.Impl(beanDeserializerFactory0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0, defaultSerializerProvider_Impl0, defaultDeserializationContext_Impl0);
Class<ReferenceType> class0 = ReferenceType.class;
ObjectReader objectReader0 = objectMapper0.readerWithView(class0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ObjectReader objectReader1 = new ObjectReader(objectReader0, tokenFilter0);
SimpleTimeZone simpleTimeZone0 = new SimpleTimeZone(0, "JSON");
simpleTimeZone0.setRawOffset(0);
objectReader0.with((TimeZone) simpleTimeZone0);
PipedReader pipedReader0 = null;
try {
pipedReader0 = new PipedReader(0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Pipe size <= 0
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test416() throws Throwable {
JsonFactory jsonFactory0 = new JsonFactory();
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory0);
objectMapper0.reader();
JsonParser jsonParser0 = null;
TypeFactory typeFactory0 = TypeFactory.defaultInstance();
Class<MissingNode> class0 = MissingNode.class;
MapLikeType mapLikeType0 = typeFactory0.constructRawMapLikeType(class0);
JsonParser.Feature[] jsonParser_FeatureArray0 = new JsonParser.Feature[8];
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_TRAILING_COMMA;
jsonParser_FeatureArray0[0] = jsonParser_Feature0;
JsonParser.Feature jsonParser_Feature1 = JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS;
jsonParser_FeatureArray0[1] = jsonParser_Feature1;
JsonParser.Feature jsonParser_Feature2 = JsonParser.Feature.ALLOW_TRAILING_COMMA;
jsonParser_FeatureArray0[2] = jsonParser_Feature2;
JsonParser.Feature jsonParser_Feature3 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
jsonParser_FeatureArray0[3] = jsonParser_Feature3;
JsonParser.Feature jsonParser_Feature4 = JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION;
jsonParser_FeatureArray0[4] = jsonParser_Feature4;
JsonParser.Feature jsonParser_Feature5 = JsonParser.Feature.AUTO_CLOSE_SOURCE;
jsonParser_FeatureArray0[5] = jsonParser_Feature5;
JsonParser.Feature jsonParser_Feature6 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
jsonParser_FeatureArray0[6] = jsonParser_Feature6;
JsonParser.Feature jsonParser_Feature7 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
jsonParser_FeatureArray0[7] = jsonParser_Feature7;
objectMapper0.enable(jsonParser_FeatureArray0);
MapLikeType mapLikeType1 = MapLikeType.upgradeFrom(mapLikeType0, mapLikeType0, mapLikeType0);
mapLikeType0.withKeyType(mapLikeType1);
ArrayNode arrayNode0 = new ArrayNode((JsonNodeFactory) null, 2698);
// Undeclared exception!
try {
arrayNode0.booleanNode(true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.node.ContainerNode", e);
}
}
@Test(timeout = 4000)
public void test417() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
ObjectMapper objectMapper1 = new ObjectMapper(objectMapper0);
ObjectReader objectReader0 = objectMapper1.reader((Base64Variant) null);
PipedReader pipedReader0 = new PipedReader();
try {
objectReader0.readValues((Reader) pipedReader0);
fail("Expecting exception: IOException");
} catch(IOException e) {
//
// Pipe not connected
//
verifyException("java.io.PipedReader", e);
}
}
@Test(timeout = 4000)
public void test418() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = JsonNodeFactory.withExactBigDecimals(false);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
byte[] byteArray0 = new byte[1];
// Undeclared exception!
try {
objectMapper0.valueToTree((Object) objectReader0);
fail("Expecting exception: NoClassDefFoundError");
} catch(NoClassDefFoundError e) {
//
// Could not initialize class com.fasterxml.jackson.databind.JsonMappingException
//
verifyException("com.fasterxml.jackson.databind.ser.std.BeanSerializerBase", e);
}
}
@Test(timeout = 4000)
public void test419() throws Throwable {
ObjectMapper objectMapper0 = new ObjectMapper();
JsonNodeFactory jsonNodeFactory0 = new JsonNodeFactory(true);
ObjectReader objectReader0 = objectMapper0.reader(jsonNodeFactory0);
DeserializationFeature deserializationFeature0 = DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY;
objectReader0.isEnabled(deserializationFeature0);
ObjectReader[] objectReaderArray0 = new ObjectReader[0];
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(objectReaderArray0);
Class<MapLikeType> class0 = MapLikeType.class;
SimpleType simpleType0 = SimpleType.constructUnsafe(class0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType(simpleType0);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(0);
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
DataFormatReaders dataFormatReaders3 = dataFormatReaders2.withMinimalMatch(matchStrength0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-92);
DataFormatReaders.Match dataFormatReaders_Match0 = dataFormatReaders3.findFormat(byteArray0);
// Undeclared exception!
try {
objectReader0._detectBindAndClose(dataFormatReaders_Match0, true);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("com.fasterxml.jackson.databind.ObjectReader", e);
}
}
@Test(timeout = 4000)
public void test420() throws Throwable {
JsonFactoryBuilder jsonFactoryBuilder0 = new JsonFactoryBuilder();
JsonFactory jsonFactory0 = new JsonFactory(jsonFactoryBuilder0);
JsonFactory jsonFactory1 = jsonFactory0.copy();
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonFactory jsonFactory2 = jsonFactory1.enable(jsonGenerator_Feature0);
ObjectMapper objectMapper0 = new ObjectMapper(jsonFactory2);
ObjectReader objectReader0 = objectMapper0.readerForUpdating(jsonFactory1);
LinkedList<ObjectReader> linkedList0 = new LinkedList<ObjectReader>();
DataFormatReaders dataFormatReaders0 = new DataFormatReaders(linkedList0);
DataFormatReaders dataFormatReaders1 = dataFormatReaders0.withType((JavaType) null);
DataFormatReaders dataFormatReaders2 = dataFormatReaders1.withMaxInputLookahead(64);
dataFormatReaders0.withMaxInputLookahead((-3909));
MatchStrength matchStrength0 = MatchStrength.WEAK_MATCH;
byte[] byteArray0 = new byte[7];
MatchStrength matchStrength1 = MatchStrength.INCONCLUSIVE;
dataFormatReaders1.withOptimalMatch(matchStrength1);
byteArray0[0] = (byte) (-45);
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)90;
byteArray0[3] = (byte)13;
byteArray0[4] = (byte)26;
byteArray0[5] = (byte) (-10);
byteArray0[6] = (byte)3;
dataFormatReaders2.findFormat(byteArray0, (int) (byte)3, (int) (byte)90);
DataFormatReaders dataFormatReaders3 = dataFormatReaders2.withMinimalMatch(matchStrength0);
objectReader0.withFormatDetection(dataFormatReaders3);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
ObjectReader objectReader1 = objectReader0.with(jsonParser_Feature0);
assertNotSame(objectReader1, objectReader0);
}
}
| [
"[email protected]"
] | |
18769e2c42dd90aa204edd6fa8128f0578cf892e | 0529524c95045b3232f6553d18a7fef5a059545e | /app/src/androidTest/java/TestCase_ae_gov_dxbpp_smartprosecution_870316683.java | 85e4b1dd7796f1e46cd64f3568f41c8e9918c78f | [] | no_license | sunxiaobiu/BasicUnitAndroidTest | 432aa3e10f6a1ef5d674f269db50e2f1faad2096 | fed24f163d21408ef88588b8eaf7ce60d1809931 | refs/heads/main | 2023-02-11T21:02:03.784493 | 2021-01-03T10:07:07 | 2021-01-03T10:07:07 | 322,577,379 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 540 | java | import android.content.Context;
import android.os.Vibrator;
import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
public class TestCase_ae_gov_dxbpp_smartprosecution_870316683 {
@Test
public void testCase() throws Exception {
Context var1 = InstrumentationRegistry.getTargetContext();
Object var2 = var1.getSystemService("vibrator");
Vibrator var3 = (Vibrator)var2;
var3.cancel();
}
}
| [
"[email protected]"
] | |
c6f16d127c2007e21530916b29fdeab992027044 | f96c5c414c331a8311ccd7ce35877373dd405820 | /CSVAPI/src/test/java/com/csvapi/test/global/TestSuiteAll.java | 46f5bf549d26018a0abb70a36ed54eaed3a276d1 | [
"MIT"
] | permissive | xresch/CSVComparator | 864f35d78540f1d9c60eada69e5b438fa9d6ebe3 | fdf3ce9bc2c3fe01f174fa38dca5bebe0ffd7d41 | refs/heads/master | 2023-07-28T11:29:05.925435 | 2021-09-06T16:30:14 | 2021-09-06T16:30:14 | 299,827,250 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 641 | java | package com.csvapi.test.global;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.csvapi.test.compare.TestCSVAPICompare;
import com.csvapi.test.compare.TestColumnMethods;
import com.csvapi.test.compare.TestCompareMethods;
import com.csvapi.test.model.TestCSVData;
import com.csvapi.test.transform.TestCSVAPITransform;
@RunWith(Suite.class)
@SuiteClasses({ TestColumnMethods.class,
TestCompareMethods.class,
TestCSVData.class,
TestCSVAPICompare.class,
TestCSVAPITransform.class
})
public class TestSuiteAll {
}
| [
"[email protected]"
] | |
f3cad3946f85b4188157b53667b4d599a38125ee | 5d522758a4fae91d16920d6666253343ecf44f3a | /src/main/java/com/yang/springboot/Listener/MySpringApplicationRunListener.java | 169040ec0cef644a63505b08c5540fad05499ae9 | [] | no_license | One-mini-learner-yang/springboot | d1806b741755a7e790f4ebb0dffd063f1a36718f | 948a176d73995eff9c1d8691f460a955f93f0d80 | refs/heads/master | 2022-06-22T06:02:47.129140 | 2020-09-03T12:27:06 | 2020-09-03T12:27:06 | 241,908,715 | 0 | 0 | null | 2022-06-17T03:23:52 | 2020-02-20T14:43:54 | Java | UTF-8 | Java | false | false | 1,235 | java | package com.yang.springboot.Listener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.env.ConfigurableEnvironment;
public class MySpringApplicationRunListener implements SpringApplicationRunListener {
public MySpringApplicationRunListener(SpringApplication application, String[] args) {
}
@Override
public void starting(){
Logger logger= LoggerFactory.getLogger(getClass().getName());
logger.error("Starting....");
}
@Override
public void environmentPrepared(ConfigurableEnvironment environment){
Logger logger= LoggerFactory.getLogger(getClass().getName());
logger.info("environmentPrepared......");
}
@Override
public void contextPrepared(ConfigurableApplicationContext context){
Logger logger= LoggerFactory.getLogger(getClass().getName());
logger.info("contextPrepared.......");
}
}
| [
"[email protected]"
] | |
2817b738edd0bdbc93973f76c67680672241d9e1 | 5598faaaaa6b3d1d8502cbdaca903f9037d99600 | /code_changes/Apache_projects/MAPREDUCE-24/22f3eeb332338aca9b834e51cc3bbe1c4d79de07/JobHistory.java | a904d843c199466622f057e03fbd7e4edbbcac4a | [] | no_license | SPEAR-SE/LogInBugReportsEmpirical_Data | 94d1178346b4624ebe90cf515702fac86f8e2672 | ab9603c66899b48b0b86bdf63ae7f7a604212b29 | refs/heads/master | 2022-12-18T02:07:18.084659 | 2020-09-09T16:49:34 | 2020-09-09T16:49:34 | 286,338,252 | 0 | 2 | null | null | null | null | UTF-8 | Java | false | false | 102,208 | java | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.mapred;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.fs.permission.FsAction;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.mapreduce.JobACL;
import org.apache.hadoop.security.authorize.AccessControlList;
import org.apache.hadoop.util.StringUtils;
import org.apache.hadoop.util.DiskChecker.DiskErrorException;
/**
* Provides methods for writing to and reading from job history.
* Job History works in an append mode, JobHistory and its inner classes provide methods
* to log job events.
*
* JobHistory is split into multiple files, format of each file is plain text where each line
* is of the format [type (key=value)*], where type identifies the type of the record.
* Type maps to UID of one of the inner classes of this class.
*
* Job history is maintained in a master index which contains star/stop times of all jobs with
* a few other job level properties. Apart from this each job's history is maintained in a seperate history
* file. name of job history files follows the format jobtrackerId_jobid
*
* For parsing the job history it supports a listener based interface where each line is parsed
* and passed to listener. The listener can create an object model of history or look for specific
* events and discard rest of the history.
*
* CHANGE LOG :
* Version 0 : The history has the following format :
* TAG KEY1="VALUE1" KEY2="VALUE2" and so on.
TAG can be Job, Task, MapAttempt or ReduceAttempt.
Note that a '"' is the line delimiter.
* Version 1 : Changes the line delimiter to '.'
Values are now escaped for unambiguous parsing.
Added the Meta tag to store version info.
*/
public class JobHistory {
static final long VERSION = 1L;
static final int DONE_DIRECTORY_FORMAT_VERSION = 1;
static final String DONE_DIRECTORY_FORMAT_DIRNAME
= "version-" + DONE_DIRECTORY_FORMAT_VERSION;
static final String UNDERSCORE_ESCAPE = "%5F";
public static final Log LOG = LogFactory.getLog(JobHistory.class);
private static final char DELIMITER = ' ';
static final char LINE_DELIMITER_CHAR = '.';
static final char[] charsToEscape = new char[] {'"', '=',
LINE_DELIMITER_CHAR};
static final String DIGITS = "[0-9]+";
static final String KEY = "(\\w+)";
// value is any character other than quote, but escaped quotes can be there
static final String VALUE = "[^\"\\\\]*+(?:\\\\.[^\"\\\\]*+)*+";
static final Pattern pattern = Pattern.compile(KEY + "=" + "\"" + VALUE + "\"");
static final int MAXIMUM_DATESTRING_COUNT = 200000;
public static final int JOB_NAME_TRIM_LENGTH = 50;
private static String JOBTRACKER_UNIQUE_STRING = null;
private static final String JOBHISTORY_DEBUG_MODE =
"mapreduce.jobhistory.debug.mode";
private static String LOG_DIR = null;
private static final String SECONDARY_FILE_SUFFIX = ".recover";
private static long jobHistoryBlockSize = 0;
private static String jobtrackerHostname;
private static JobHistoryFilesManager fileManager = null;
final static FsPermission HISTORY_DIR_PERMISSION =
FsPermission.createImmutable((short) 0755); // rwxr-xr-x
final static FsPermission HISTORY_FILE_PERMISSION =
FsPermission.createImmutable((short) 0744); // rwxr--r--
private static FileSystem LOGDIR_FS; // log dir filesystem
private static FileSystem DONEDIR_FS; // Done dir filesystem
private static JobConf jtConf;
private static Path DONE = null; // folder for completed jobs
private static String DONE_BEFORE_SERIAL_TAIL = doneSubdirsBeforeSerialTail();
private static String DONE_LEAF_FILES = DONE_BEFORE_SERIAL_TAIL + "/*";
private static boolean aclsEnabled = false;
static final String CONF_FILE_NAME_SUFFIX = "_conf.xml";
// XXXXX debug mode -- set this to false for production
private static boolean DEBUG_MODE;
private static final int SERIAL_NUMBER_DIRECTORY_DIGITS = 6;
private static int SERIAL_NUMBER_LOW_DIGITS;
private static String SERIAL_NUMBER_FORMAT;
private static final Set<Path> existingDoneSubdirs = new HashSet<Path>();
private static final SortedMap<Integer, String> idToDateString
= new TreeMap<Integer, String>();
/**
* A filter for conf files
*/
private static final PathFilter CONF_FILTER = new PathFilter() {
public boolean accept(Path path) {
return path.getName().endsWith(CONF_FILE_NAME_SUFFIX);
}
};
private static final Map<JobID, MovedFileInfo> jobHistoryFileMap =
Collections.<JobID,MovedFileInfo>synchronizedMap(
new LinkedHashMap<JobID, MovedFileInfo>());
private static final SortedMap<Long, String>jobToDirectoryMap
= new TreeMap<Long, String>();
// JobHistory filename regex
public static final Pattern JOBHISTORY_FILENAME_REGEX =
Pattern.compile("(" + JobID.JOBID_REGEX + ")_.+");
// JobHistory conf-filename regex
public static final Pattern CONF_FILENAME_REGEX =
Pattern.compile("(" + JobID.JOBID_REGEX + ")_conf.xml");
private static class MovedFileInfo {
private final String historyFile;
private final long timestamp;
public MovedFileInfo(String historyFile, long timestamp) {
this.historyFile = historyFile;
this.timestamp = timestamp;
}
}
/**
* Given the job id, return the history file path from the cache
*/
public static String getHistoryFilePath(JobID jobId) {
MovedFileInfo info = jobHistoryFileMap.get(jobId);
if (info == null) {
return null;
}
return info.historyFile;
}
/**
* A class that manages all the files related to a job. For now
* - writers : list of open files
* - job history filename
* - job conf filename
*/
private static class JobHistoryFilesManager {
// a private (virtual) folder for all the files related to a running job
private static class FilesHolder {
ArrayList<PrintWriter> writers = new ArrayList<PrintWriter>();
Path historyFilename; // path of job history file
Path confFilename; // path of job's conf
}
private ThreadPoolExecutor executor = null;
private final Configuration conf;
private final JobTracker jobTracker;
// cache from job-key to files associated with it.
private Map<JobID, FilesHolder> fileCache =
new ConcurrentHashMap<JobID, FilesHolder>();
JobHistoryFilesManager(Configuration conf, JobTracker jobTracker)
throws IOException {
this.conf = conf;
this.jobTracker = jobTracker;
}
void start() {
executor = new ThreadPoolExecutor(1, 3, 1,
TimeUnit.HOURS, new LinkedBlockingQueue<Runnable>());
}
private FilesHolder getFileHolder(JobID id) {
FilesHolder holder = fileCache.get(id);
if (holder == null) {
holder = new FilesHolder();
fileCache.put(id, holder);
}
return holder;
}
void addWriter(JobID id, PrintWriter writer) {
FilesHolder holder = getFileHolder(id);
holder.writers.add(writer);
}
void setHistoryFile(JobID id, Path file) {
FilesHolder holder = getFileHolder(id);
holder.historyFilename = file;
}
void setConfFile(JobID id, Path file) {
FilesHolder holder = getFileHolder(id);
holder.confFilename = file;
}
ArrayList<PrintWriter> getWriters(JobID id) {
FilesHolder holder = fileCache.get(id);
return holder == null ? null : holder.writers;
}
Path getHistoryFile(JobID id) {
FilesHolder holder = fileCache.get(id);
return holder == null ? null : holder.historyFilename;
}
Path getConfFileWriters(JobID id) {
FilesHolder holder = fileCache.get(id);
return holder == null ? null : holder.confFilename;
}
void purgeJob(JobID id) {
fileCache.remove(id);
}
void moveToDone(final JobID id) {
final List<Path> paths = new ArrayList<Path>();
final Path historyFile = fileManager.getHistoryFile(id);
if (historyFile == null) {
LOG.info("No file for job-history with " + id + " found in cache!");
} else {
paths.add(historyFile);
}
final Path confPath = fileManager.getConfFileWriters(id);
if (confPath == null) {
LOG.info("No file for jobconf with " + id + " found in cache!");
} else {
paths.add(confPath);
}
executor.execute(new Runnable() {
public void run() {
long millisecondTime = System.currentTimeMillis();
Path resultDir = canonicalHistoryLogPath(id, millisecondTime);
//move the files to DONE canonical subfolder
try {
for (Path path : paths) {
//check if path exists, in case of retries it may not exist
if (LOGDIR_FS.exists(path)) {
maybeMakeSubdirectory(id, millisecondTime);
LOG.info("Moving " + path.toString() + " to " +
resultDir.toString());
DONEDIR_FS.moveFromLocalFile(path, resultDir);
DONEDIR_FS.setPermission(new Path(resultDir, path.getName()),
new FsPermission(HISTORY_FILE_PERMISSION));
}
}
} catch (Throwable e) {
LOG.error("Unable to move history file to DONE canonical subfolder.", e);
}
String historyFileDonePath = null;
if (historyFile != null) {
historyFileDonePath = new Path(resultDir,
historyFile.getName()).toString();
}
jobHistoryFileMap.put(id, new MovedFileInfo(historyFileDonePath,
millisecondTime));
jobTracker.historyFileCopied(id, historyFileDonePath);
//purge the job from the cache
fileManager.purgeJob(id);
}
});
}
void removeWriter(JobID jobId, PrintWriter writer) {
fileManager.getWriters(jobId).remove(writer);
}
}
// several methods for manipulating the subdirectories of the DONE
// directory
private static int jobSerialNumber(JobID id) {
return id.getId();
}
private static String serialNumberDirectoryComponent(JobID id) {
return String.format(SERIAL_NUMBER_FORMAT,
Integer.valueOf(jobSerialNumber(id)))
.substring(0, SERIAL_NUMBER_DIRECTORY_DIGITS);
}
// directory components may contain internal slashes, but do NOT
// contain slashes at either end.
private static String timestampDirectoryComponent(JobID id, long millisecondTime) {
int serialNumber = jobSerialNumber(id);
Integer boxedSerialNumber = serialNumber;
// don't want to do this inside the lock
Calendar timestamp = Calendar.getInstance();
timestamp.setTimeInMillis(millisecondTime);
synchronized (idToDateString) {
String dateString = idToDateString.get(boxedSerialNumber);
if (dateString == null) {
dateString = String.format
("%04d/%02d/%02d",
timestamp.get(Calendar.YEAR),
// months are 0-based in Calendar, but people will expect January
// to be month #1.
timestamp.get(DEBUG_MODE ? Calendar.HOUR : Calendar.MONTH) + 1,
timestamp.get(DEBUG_MODE ? Calendar.MINUTE : Calendar.DAY_OF_MONTH));
dateString = dateString.intern();
idToDateString.put(boxedSerialNumber, dateString);
if (idToDateString.size() > MAXIMUM_DATESTRING_COUNT) {
idToDateString.remove(idToDateString.firstKey());
}
}
return dateString;
}
}
// returns false iff the directory already existed
private static boolean maybeMakeSubdirectory(JobID id, long millisecondTime)
throws IOException {
Path dir = canonicalHistoryLogPath(id, millisecondTime);
synchronized (existingDoneSubdirs) {
if (existingDoneSubdirs.contains(dir)) {
if (DEBUG_MODE && !DONEDIR_FS.exists(dir)) {
System.err.println("JobHistory.maybeMakeSubdirectory -- We believed "
+ dir + " already existed, but it didn't.");
}
return true;
}
if (!DONEDIR_FS.exists(dir)) {
LOG.info("Creating DONE subfolder at "+ dir);
if (!FileSystem.mkdirs(DONEDIR_FS, dir,
new FsPermission(HISTORY_DIR_PERMISSION))) {
throw new IOException("Mkdirs failed to create " + dir.toString());
}
existingDoneSubdirs.add(dir);
return false;
} else {
if (DEBUG_MODE) {
System.err.println("JobHistory.maybeMakeSubdirectory -- We believed "
+ dir + " didn't already exist, but it did.");
}
return false;
}
}
}
private static Path canonicalHistoryLogPath(JobID id, long millisecondTime) {
return new Path(DONE, historyLogSubdirectory(id, millisecondTime));
}
private static String historyLogSubdirectory(JobID id, long millisecondTime) {
String result
= (DONE_DIRECTORY_FORMAT_DIRNAME
+ "/" + jobtrackerDirectoryComponent(id));
String serialNumberDirectory = serialNumberDirectoryComponent(id);
result = (result
+ "/" + timestampDirectoryComponent(id, millisecondTime)
+ "/" + serialNumberDirectory
+ "/");
return result;
}
private static String jobtrackerDirectoryComponent(JobID id) {
return JOBTRACKER_UNIQUE_STRING;
}
private static String doneSubdirsBeforeSerialTail() {
// job tracker ID
String result
= ("/" + DONE_DIRECTORY_FORMAT_DIRNAME
+ "/*"); // job tracker instance ID
// date
result = result + "/*/*/*"; // YYYY/MM/DD ;
return result;
}
/**
* Record types are identifiers for each line of log in history files.
* A record type appears as the first token in a single line of log.
*/
public static enum RecordTypes {
Jobtracker, Job, Task, MapAttempt, ReduceAttempt, Meta
}
/**
* Job history files contain key="value" pairs, where keys belong to this enum.
* It acts as a global namespace for all keys.
*/
public static enum Keys {
JOBTRACKERID,
START_TIME, FINISH_TIME, JOBID, JOBNAME, USER, JOBCONF, SUBMIT_TIME,
LAUNCH_TIME, TOTAL_MAPS, TOTAL_REDUCES, FAILED_MAPS, FAILED_REDUCES,
FINISHED_MAPS, FINISHED_REDUCES, JOB_STATUS, TASKID, HOSTNAME, TASK_TYPE,
ERROR, TASK_ATTEMPT_ID, TASK_STATUS, COPY_PHASE, SORT_PHASE, REDUCE_PHASE,
SHUFFLE_FINISHED, SORT_FINISHED, COUNTERS, SPLITS, JOB_PRIORITY, HTTP_PORT,
TRACKER_NAME, STATE_STRING, VERSION, MAP_COUNTERS, REDUCE_COUNTERS,
VIEW_JOB, MODIFY_JOB, JOB_QUEUE, FAIL_REASON
}
/**
* This enum contains some of the values commonly used by history log events.
* since values in history can only be strings - Values.name() is used in
* most places in history file.
*/
public static enum Values {
SUCCESS, FAILED, KILLED, MAP, REDUCE, CLEANUP, RUNNING, PREP, SETUP
}
/**
* Initialize JobHistory files.
* @param conf Jobconf of the job tracker.
* @param hostname jobtracker's hostname
* @param jobTrackerStartTime jobtracker's start time
*/
public static void init(JobTracker jobTracker, JobConf conf,
String hostname, long jobTrackerStartTime) throws IOException {
initLogDir(conf);
DEBUG_MODE = conf.getBoolean(JOBHISTORY_DEBUG_MODE, false);
SERIAL_NUMBER_LOW_DIGITS = DEBUG_MODE ? 1 : 3;
SERIAL_NUMBER_FORMAT = ("%0"
+ (SERIAL_NUMBER_DIRECTORY_DIGITS + SERIAL_NUMBER_LOW_DIGITS)
+ "d");
JOBTRACKER_UNIQUE_STRING = hostname + "_" +
String.valueOf(jobTrackerStartTime) + "_";
jobtrackerHostname = hostname;
Path logDir = new Path(LOG_DIR);
if (!LOGDIR_FS.exists(logDir)){
if (!LOGDIR_FS.mkdirs(logDir, new FsPermission(HISTORY_DIR_PERMISSION))) {
throw new IOException("Mkdirs failed to create " + logDir.toString());
}
} else { // directory exists
checkDirectoryPermissions(LOGDIR_FS, logDir, "hadoop.job.history.location");
}
conf.set("hadoop.job.history.location", LOG_DIR);
// set the job history block size (default is 3MB)
jobHistoryBlockSize =
conf.getLong("mapred.jobtracker.job.history.block.size",
3 * 1024 * 1024);
jtConf = conf;
// queue and job level security is enabled on the mapreduce cluster or not
aclsEnabled = conf.getBoolean(JobConf.MR_ACLS_ENABLED, false);
// initialize the file manager
fileManager = new JobHistoryFilesManager(conf, jobTracker);
}
private static void initLogDir(JobConf conf) throws IOException {
LOG_DIR = conf.get("hadoop.job.history.location" ,
"file:///" + new File(
System.getProperty("hadoop.log.dir")).getAbsolutePath()
+ File.separator + "history");
Path logDir = new Path(LOG_DIR);
LOGDIR_FS = logDir.getFileSystem(conf);
}
static void initDone(JobConf conf, FileSystem fs) throws IOException {
initDone(conf, fs, true);
}
static void initDone(JobConf conf, FileSystem fs,
boolean setup)
throws IOException {
//if completed job history location is set, use that
String doneLocation = conf.
get("mapred.job.tracker.history.completed.location");
if (doneLocation != null) {
DONE = fs.makeQualified(new Path(doneLocation));
DONEDIR_FS = fs;
} else {
if (!setup) {
initLogDir(conf);
}
DONE = new Path(LOG_DIR, "done");
DONEDIR_FS = LOGDIR_FS;
}
Path versionSubdir = new Path(DONE, DONE_DIRECTORY_FORMAT_DIRNAME);
//If not already present create the done folder with appropriate
//permission
if (!DONEDIR_FS.exists(DONE)) {
LOG.info("Creating DONE folder at "+ DONE);
if (!DONEDIR_FS.mkdirs(DONE,
new FsPermission(HISTORY_DIR_PERMISSION))) {
throw new IOException("Mkdirs failed to create " + DONE.toString());
}
if (!DONEDIR_FS.exists(versionSubdir)) {
if (!DONEDIR_FS.mkdirs(versionSubdir,
new FsPermission(HISTORY_DIR_PERMISSION))) {
throw new IOException("Mkdirs failed to create " + versionSubdir);
}
}
} else { // directory exists. Checks version subdirectory permissions as
// well.
checkDirectoryPermissions(DONEDIR_FS, DONE,
"mapred.job.tracker.history.completed.location");
if (DONEDIR_FS.exists(versionSubdir))
checkDirectoryPermissions(DONEDIR_FS, versionSubdir,
"mapred.job.tracker.history.completed.location-versionsubdir");
}
if (!setup) {
return;
}
fileManager.start();
}
/**
* @param FileSystem
* @param Path
* @param configKey
* @throws IOException
* @throws DiskErrorException
*/
static void checkDirectoryPermissions(FileSystem fs, Path path,
String configKey) throws IOException, DiskErrorException {
FileStatus stat = fs.getFileStatus(path);
FsPermission actual = stat.getPermission();
if (!stat.isDir())
throw new DiskErrorException(configKey + " - not a directory: "
+ path.toString());
FsAction user = actual.getUserAction();
if (!user.implies(FsAction.READ))
throw new DiskErrorException("bad " + configKey
+ "- directory is not readable: " + path.toString());
if (!user.implies(FsAction.WRITE))
throw new DiskErrorException("bad " + configKey
+ "- directory is not writable " + path.toString());
}
/**
* Manages job-history's meta information such as version etc.
* Helps in logging version information to the job-history and recover
* version information from the history.
*/
static class MetaInfoManager implements Listener {
private long version = 0L;
private KeyValuePair pairs = new KeyValuePair();
// Extract the version of the history that was used to write the history
public MetaInfoManager(String line) throws IOException {
if (null != line) {
// Parse the line
parseLine(line, this, false);
}
}
// Get the line delimiter
char getLineDelim() {
if (version == 0) {
return '"';
} else {
return LINE_DELIMITER_CHAR;
}
}
// Checks if the values are escaped or not
boolean isValueEscaped() {
// Note that the values are not escaped in version 0
return version != 0;
}
public void handle(RecordTypes recType, Map<Keys, String> values)
throws IOException {
// Check if the record is of type META
if (RecordTypes.Meta == recType) {
pairs.handle(values);
version = pairs.getLong(Keys.VERSION); // defaults to 0
}
}
/**
* Logs history meta-info to the history file. This needs to be called once
* per history file.
* @param jobId job id, assigned by jobtracker.
*/
static void logMetaInfo(ArrayList<PrintWriter> writers){
if (null != writers){
JobHistory.log(writers, RecordTypes.Meta,
new Keys[] {Keys.VERSION},
new String[] {String.valueOf(VERSION)});
}
}
}
/** Escapes the string especially for {@link JobHistory}
*/
static String escapeString(String data) {
return StringUtils.escapeString(data, StringUtils.ESCAPE_CHAR,
charsToEscape);
}
/**
* Parses history file and invokes Listener.handle() for
* each line of history. It can be used for looking through history
* files for specific items without having to keep whole history in memory.
* @param path path to history file
* @param l Listener for history events
* @param fs FileSystem where history file is present
* @throws IOException
*/
public static void parseHistoryFromFS(String path, Listener l, FileSystem fs)
throws IOException{
FSDataInputStream in = fs.open(new Path(path));
BufferedReader reader = new BufferedReader(new InputStreamReader (in));
try {
String line = null;
StringBuffer buf = new StringBuffer();
// Read the meta-info line. Note that this might a jobinfo line for files
// written with older format
line = reader.readLine();
// Check if the file is empty
if (line == null) {
return;
}
// Get the information required for further processing
MetaInfoManager mgr = new MetaInfoManager(line);
boolean isEscaped = mgr.isValueEscaped();
String lineDelim = String.valueOf(mgr.getLineDelim());
String escapedLineDelim =
StringUtils.escapeString(lineDelim, StringUtils.ESCAPE_CHAR,
mgr.getLineDelim());
do {
buf.append(line);
if (!line.trim().endsWith(lineDelim)
|| line.trim().endsWith(escapedLineDelim)) {
buf.append("\n");
continue;
}
parseLine(buf.toString(), l, isEscaped);
buf = new StringBuffer();
} while ((line = reader.readLine())!= null);
} finally {
try { reader.close(); } catch (IOException ex) {}
}
}
/**
* Parse a single line of history.
* @param line
* @param l
* @throws IOException
*/
private static void parseLine(String line, Listener l, boolean isEscaped)
throws IOException{
// extract the record type
int idx = line.indexOf(' ');
String recType = line.substring(0, idx);
String data = line.substring(idx+1, line.length());
Matcher matcher = pattern.matcher(data);
Map<Keys,String> parseBuffer = new HashMap<Keys, String>();
while(matcher.find()){
String tuple = matcher.group(0);
String []parts = StringUtils.split(tuple, StringUtils.ESCAPE_CHAR, '=');
String value = parts[1].substring(1, parts[1].length() -1);
if (isEscaped) {
value = StringUtils.unEscapeString(value, StringUtils.ESCAPE_CHAR,
charsToEscape);
}
parseBuffer.put(Keys.valueOf(parts[0]), value);
}
l.handle(RecordTypes.valueOf(recType), parseBuffer);
parseBuffer.clear();
}
/**
* Log a raw record type with keys and values. This is method is generally not used directly.
* @param recordType type of log event
* @param key key
* @param value value
*/
static void log(PrintWriter out, RecordTypes recordType, Keys key,
String value){
value = escapeString(value);
out.println(recordType.name() + DELIMITER + key + "=\"" + value + "\""
+ DELIMITER + LINE_DELIMITER_CHAR);
}
/**
* Log a number of keys and values with record. the array length of keys and values
* should be same.
* @param recordType type of log event
* @param keys type of log event
* @param values type of log event
*/
/**
* Log a number of keys and values with record. the array length of keys and values
* should be same.
* @param recordType type of log event
* @param keys type of log event
* @param values type of log event
*/
static void log(ArrayList<PrintWriter> writers, RecordTypes recordType,
Keys[] keys, String[] values) {
log(writers, recordType, keys, values, null);
}
/**
* Log a number of keys and values with record. the array length of keys and values
* should be same.
* @param recordType type of log event
* @param keys type of log event
* @param values type of log event
* @param JobID jobid of the job
*/
static void log(ArrayList<PrintWriter> writers, RecordTypes recordType,
Keys[] keys, String[] values, JobID id) {
// First up calculate the length of buffer, so that we are performant
// enough.
int length = recordType.name().length() + keys.length * 4 + 2;
for (int i = 0; i < keys.length; i++) {
values[i] = escapeString(values[i]);
length += values[i].length() + keys[i].toString().length();
}
// We have the length of the buffer, now construct it.
StringBuilder builder = new StringBuilder(length);
builder.append(recordType.name());
builder.append(DELIMITER);
for(int i =0; i< keys.length; i++){
builder.append(keys[i]);
builder.append("=\"");
builder.append(values[i]);
builder.append("\"");
builder.append(DELIMITER);
}
builder.append(LINE_DELIMITER_CHAR);
for (Iterator<PrintWriter> iter = writers.iterator(); iter.hasNext();) {
PrintWriter out = iter.next();
out.println(builder.toString());
if (out.checkError() && id != null) {
LOG.info("Logging failed for job " + id + "removing PrintWriter from FileManager");
iter.remove();
}
}
}
/**
* Get the history location
*/
static Path getJobHistoryLocation() {
return new Path(LOG_DIR);
}
/**
* Get the history location for completed jobs
*/
static Path getCompletedJobHistoryLocation() {
return DONE;
}
static int serialNumberDirectoryDigits() {
return SERIAL_NUMBER_DIRECTORY_DIGITS;
}
static int serialNumberTotalDigits() {
return serialNumberDirectoryDigits() + SERIAL_NUMBER_LOW_DIGITS;
}
/**
* Get the
*/
/**
* Base class contais utility stuff to manage types key value pairs with enums.
*/
static class KeyValuePair{
private Map<Keys, String> values = new HashMap<Keys, String>();
/**
* Get 'String' value for given key. Most of the places use Strings as
* values so the default get' method returns 'String'. This method never returns
* null to ease on GUIs. if no value is found it returns empty string ""
* @param k
* @return if null it returns empty string - ""
*/
public String get(Keys k){
String s = values.get(k);
return s == null ? "" : s;
}
/**
* Convert value from history to int and return.
* if no value is found it returns 0.
* @param k key
*/
public int getInt(Keys k){
String s = values.get(k);
if (null != s){
return Integer.parseInt(s);
}
return 0;
}
/**
* Convert value from history to int and return.
* if no value is found it returns 0.
* @param k
*/
public long getLong(Keys k){
String s = values.get(k);
if (null != s){
return Long.parseLong(s);
}
return 0;
}
/**
* Set value for the key.
* @param k
* @param s
*/
public void set(Keys k, String s){
values.put(k, s);
}
/**
* Adds all values in the Map argument to its own values.
* @param m
*/
public void set(Map<Keys, String> m){
values.putAll(m);
}
/**
* Reads values back from the history, input is same Map as passed to Listener by parseHistory().
* @param values
*/
public synchronized void handle(Map<Keys, String> values){
set(values);
}
/**
* Returns Map containing all key-values.
*/
public Map<Keys, String> getValues(){
return values;
}
}
// hasMismatches is just used to return a second value if you want
// one. I would have used MutableBoxedBoolean if such had been provided.
static Path[] filteredStat2Paths
(FileStatus[] stats, boolean dirs, AtomicBoolean hasMismatches) {
int resultCount = 0;
if (hasMismatches == null) {
hasMismatches = new AtomicBoolean(false);
}
for (int i = 0; i < stats.length; ++i) {
if (stats[i].isDir() == dirs) {
stats[resultCount++] = stats[i];
} else {
hasMismatches.set(true);
}
}
Path[] paddedResult = FileUtil.stat2Paths(stats);
Path[] result = new Path[resultCount];
System.arraycopy(paddedResult, 0, result, 0, resultCount);
return result;
}
static FileStatus[] localGlobber
(FileSystem fs, Path root, String tail)
throws IOException {
return localGlobber(fs, root, tail, null);
}
static FileStatus[] localGlobber
(FileSystem fs, Path root, String tail, PathFilter filter)
throws IOException {
return localGlobber(fs, root, tail, filter, null);
}
private static FileStatus[] nullToEmpty(FileStatus[] result) {
return result == null ? new FileStatus[0] : result;
}
private static FileStatus[] listFilteredStatus
(FileSystem fs, Path root, PathFilter filter)
throws IOException {
return filter == null ? fs.listStatus(root) : fs.listStatus(root, filter);
}
// hasMismatches is just used to return a second value if you want
// one. I would have used MutableBoxedBoolean if such had been provided.
static FileStatus[] localGlobber
(FileSystem fs, Path root, String tail, PathFilter filter,
AtomicBoolean hasFlatFiles)
throws IOException {
if (tail.equals("")) {
return nullToEmpty(listFilteredStatus(fs, root, filter));
}
if (tail.startsWith("/*")) {
Path[] subdirs = filteredStat2Paths(nullToEmpty(fs.listStatus(root)),
true, hasFlatFiles);
FileStatus[][] subsubdirs = new FileStatus[subdirs.length][];
int subsubdirCount = 0;
if (subsubdirs.length == 0) {
return new FileStatus[0];
}
String newTail = tail.substring(2);
for (int i = 0; i < subdirs.length; ++i) {
subsubdirs[i] = localGlobber(fs, subdirs[i], newTail, filter, null);
subsubdirCount += subsubdirs[i].length;
}
FileStatus[] result = new FileStatus[subsubdirCount];
int segmentStart = 0;
for (int i = 0; i < subsubdirs.length; ++i) {
System.arraycopy(subsubdirs[i], 0, result, segmentStart, subsubdirs[i].length);
segmentStart += subsubdirs[i].length;
}
return result;
}
if (tail.startsWith("/")) {
int split = tail.indexOf('/', 1);
if (split < 0) {
return nullToEmpty
(listFilteredStatus(fs, new Path(root, tail.substring(1)), filter));
} else {
String thisSegment = tail.substring(1, split);
String newTail = tail.substring(split);
return localGlobber
(fs, new Path(root, thisSegment), newTail, filter, hasFlatFiles);
}
}
IOException e = new IOException("localGlobber: bad tail");
throw e;
}
static Path confPathFromLogFilePath(Path logFile) {
String jobId = jobIdNameFromLogFileName(logFile.getName());
Path logDir = logFile.getParent();
return new Path(logDir, jobId + CONF_FILE_NAME_SUFFIX);
}
static String jobIdNameFromLogFileName(String logFileName) {
String[] jobDetails = logFileName.split("_");
return jobDetails[0] + "_" + jobDetails[1] + "_" + jobDetails[2];
}
static String userNameFromLogFileName(String logFileName) {
String[] jobDetails = logFileName.split("_");
return jobDetails[3];
}
static String jobNameFromLogFileName(String logFileName) {
String[] jobDetails = logFileName.split("_");
return jobDetails[4];
}
// This code will be inefficient if the subject contains dozens of underscores
static String escapeUnderscores(String escapee) {
return replaceStringInstances(escapee, "_", UNDERSCORE_ESCAPE);
}
static String nonOccursString(String logFileName) {
int adHocIndex = 0;
String unfoundString = "q" + adHocIndex;
while (logFileName.contains(unfoundString)) {
unfoundString = "q" + ++adHocIndex;
}
return unfoundString + "q";
}
// I tolerate this code because I expect a low number of
// occurrences in a relatively short string
static String replaceStringInstances
(String logFileName, String old, String replacement) {
int index = logFileName.indexOf(old);
while (index > 0) {
logFileName = (logFileName.substring(0, index)
+ replacement
+ replaceStringInstances
(logFileName.substring(index + old.length()),
old, replacement));
index = logFileName.indexOf(old);
}
return logFileName;
}
/**
* Helper class for logging or reading back events related to job start, finish or failure.
*/
public static class JobInfo extends KeyValuePair{
private Map<String, Task> allTasks = new TreeMap<String, Task>();
private Map<JobACL, AccessControlList> jobACLs =
new HashMap<JobACL, AccessControlList>();
private String queueName = null;// queue to which this job was submitted to
/** Create new JobInfo */
public JobInfo(String jobId){
set(Keys.JOBID, jobId);
}
/**
* Returns all map and reduce tasks <taskid-Task>.
*/
public Map<String, Task> getAllTasks() { return allTasks; }
/**
* Get the job acls.
*
* @return a {@link Map} from {@link JobACL} to {@link AccessControlList}
*/
public Map<JobACL, AccessControlList> getJobACLs() {
return jobACLs;
}
@Override
public synchronized void handle(Map<Keys, String> values) {
if (values.containsKey(Keys.SUBMIT_TIME)) {// job submission
// construct the job ACLs
String viewJobACL = values.get(Keys.VIEW_JOB);
String modifyJobACL = values.get(Keys.MODIFY_JOB);
if (viewJobACL != null) {
jobACLs.put(JobACL.VIEW_JOB, new AccessControlList(viewJobACL));
}
if (modifyJobACL != null) {
jobACLs.put(JobACL.MODIFY_JOB, new AccessControlList(modifyJobACL));
}
// get the job queue name
queueName = values.get(Keys.JOB_QUEUE);
}
super.handle(values);
}
String getJobQueue() {
return queueName;
}
/**
* Get the path of the locally stored job file
* @param jobId id of the job
* @return the path of the job file on the local file system
*/
public static String getLocalJobFilePath(JobID jobId){
return System.getProperty("hadoop.log.dir") + File.separator +
jobId + CONF_FILE_NAME_SUFFIX;
}
/**
* Helper function to encode the URL of the path of the job-history
* log file.
*
* @param logFile path of the job-history file
* @return URL encoded path
* @throws IOException
*/
public static String encodeJobHistoryFilePath(String logFile)
throws IOException {
Path rawPath = new Path(logFile);
String encodedFileName = null;
try {
encodedFileName = URLEncoder.encode(rawPath.getName(), "UTF-8");
} catch (UnsupportedEncodingException uee) {
IOException ioe = new IOException();
ioe.initCause(uee);
ioe.setStackTrace(uee.getStackTrace());
throw ioe;
}
Path encodedPath = new Path(rawPath.getParent(), encodedFileName);
return encodedPath.toString();
}
/**
* Helper function to encode the URL of the filename of the job-history
* log file.
*
* @param logFileName file name of the job-history file
* @return URL encoded filename
* @throws IOException
*/
public static String encodeJobHistoryFileName(String logFileName)
throws IOException {
String replacementUnderscoreEscape = null;
if (logFileName.contains(UNDERSCORE_ESCAPE)) {
replacementUnderscoreEscape = nonOccursString(logFileName);
logFileName = replaceStringInstances
(logFileName, UNDERSCORE_ESCAPE, replacementUnderscoreEscape);
}
String encodedFileName = null;
try {
encodedFileName = URLEncoder.encode(logFileName, "UTF-8");
} catch (UnsupportedEncodingException uee) {
IOException ioe = new IOException();
ioe.initCause(uee);
ioe.setStackTrace(uee.getStackTrace());
throw ioe;
}
if (replacementUnderscoreEscape != null) {
encodedFileName = replaceStringInstances
(encodedFileName, replacementUnderscoreEscape, UNDERSCORE_ESCAPE);
}
return encodedFileName;
}
/**
* Helper function to decode the URL of the filename of the job-history
* log file.
*
* @param logFileName file name of the job-history file
* @return URL decoded filename
* @throws IOException
*/
public static String decodeJobHistoryFileName(String logFileName)
throws IOException {
String decodedFileName = null;
try {
decodedFileName = URLDecoder.decode(logFileName, "UTF-8");
} catch (UnsupportedEncodingException uee) {
IOException ioe = new IOException();
ioe.initCause(uee);
ioe.setStackTrace(uee.getStackTrace());
throw ioe;
}
return decodedFileName;
}
/**
* Get the job name from the job conf
*/
static String getJobName(JobConf jobConf) {
String jobName = jobConf.getJobName();
if (jobName == null || jobName.length() == 0) {
jobName = "NA";
}
return jobName;
}
/**
* Get the user name from the job conf
*/
public static String getUserName(JobConf jobConf) {
String user = jobConf.getUser();
if (user == null || user.length() == 0) {
user = "NA";
}
return user;
}
/**
* Get the job history file path given the history filename
*/
public static Path getJobHistoryLogLocation(String logFileName)
{
return LOG_DIR == null ? null : new Path(LOG_DIR, logFileName);
}
/**
* Get the user job history file path
*/
public static Path getJobHistoryLogLocationForUser(String logFileName,
JobConf jobConf) {
// find user log directory
Path userLogFile = null;
Path outputPath = FileOutputFormat.getOutputPath(jobConf);
String userLogDir = jobConf.get("hadoop.job.history.user.location",
outputPath == null
? null
: outputPath.toString());
if ("none".equals(userLogDir)) {
userLogDir = null;
}
if (userLogDir != null) {
userLogDir = userLogDir + Path.SEPARATOR + "_logs" + Path.SEPARATOR
+ "history";
userLogFile = new Path(userLogDir, logFileName);
}
return userLogFile;
}
/**
* Generates the job history filename for a new job
*/
private static String getNewJobHistoryFileName(JobConf jobConf, JobID id, long submitTime) {
return
id.toString() + "_"
+ submitTime + "_"
+ escapeUnderscores(getUserName(jobConf)) + "_"
+ escapeUnderscores(trimJobName(getJobName(jobConf)));
}
/**
* Trims the job-name if required
*/
private static String trimJobName(String jobName) {
if (jobName.length() > JOB_NAME_TRIM_LENGTH) {
jobName = jobName.substring(0, JOB_NAME_TRIM_LENGTH);
}
return jobName;
}
private static String escapeRegexChars( String string ) {
return "\\Q"+string.replaceAll("\\\\E", "\\\\E\\\\\\\\E\\\\Q")+"\\E";
}
/**
* Recover the job history filename from the history folder.
* Uses the following pattern
* $jt-hostname_[0-9]*_$job-id_$user_$job-name*
* @param jobConf the job conf
* @param id job id
*/
public static synchronized String getJobHistoryFileName(JobConf jobConf,
JobID id)
throws IOException {
return getJobHistoryFileName(jobConf, id, new Path(LOG_DIR), LOGDIR_FS);
}
// Returns that portion of the pathname that sits under the DONE directory
static synchronized String getDoneJobHistoryFileName(JobConf jobConf,
JobID id) throws IOException {
if (DONE == null) {
return null;
}
return getJobHistoryFileName(jobConf, id, DONE, DONEDIR_FS);
}
/**
* @param dir The directory where to search.
*/
private static synchronized String getJobHistoryFileName(JobConf jobConf,
JobID id, Path dir, FileSystem fs)
throws IOException {
String user = getUserName(jobConf);
String jobName = trimJobName(getJobName(jobConf));
if (LOG_DIR == null) {
return null;
}
// Make the pattern matching the job's history file
final String regexp
= id.toString() + "_" + DIGITS + "_" + user + "_"
+ escapeRegexChars(jobName) + "+";
final Pattern historyFilePattern = Pattern.compile(regexp);
// a path filter that matches 4 parts of the filenames namely
// - jt-hostname
// - job-id
// - username
// - jobname
PathFilter filter = new PathFilter() {
public boolean accept(Path path) {
String unescapedFileName = path.getName();
String fileName = null;
try {
fileName = decodeJobHistoryFileName(unescapedFileName);
} catch (IOException ioe) {
LOG.info("Error while decoding history file " + fileName + "."
+ " Ignoring file.", ioe);
return false;
}
return historyFilePattern.matcher(fileName).find();
}
};
FileStatus[] statuses = null;
if (dir == DONE) {
final String snDirectoryComponent
= serialNumberDirectoryComponent(id);
final String scanTail
= (DONE_BEFORE_SERIAL_TAIL
+ "/" + serialNumberDirectoryComponent(id));
if (DEBUG_MODE) {
System.err.println("JobHistory.getJobHistoryFileName DONE dir: scanning " + scanTail);
(new IOException("debug exception")).printStackTrace(System.err);
}
statuses = localGlobber(fs, DONE, scanTail, filter);
} else {
statuses = fs.listStatus(dir, filter);
}
String filename = null;
if (statuses == null || statuses.length == 0) {
if (DEBUG_MODE) {
System.err.println("Nothing to recover for job " + id);
}
LOG.info("Nothing to recover for job " + id);
} else {
// return filename considering that fact the name can be a
// secondary filename like filename.recover
filename = getPrimaryFilename(statuses[0].getPath().getName(), jobName);
if (dir == DONE) {
Path parent = statuses[0].getPath().getParent();
String parentPathName = parent.toString();
String donePathName = DONE.toString();
filename = (parentPathName.substring(donePathName.length() + Path.SEPARATOR.length())
+ Path.SEPARATOR + filename);
}
LOG.info("Recovered job history filename for job " + id + " is "
+ filename);
}
return filename;
}
// removes all extra extensions from a filename and returns the core/primary
// filename
private static String getPrimaryFilename(String filename, String jobName)
throws IOException{
filename = decodeJobHistoryFileName(filename);
// Remove the '.recover' suffix if it exists
if (filename.endsWith(jobName + SECONDARY_FILE_SUFFIX)) {
int newLength = filename.length() - SECONDARY_FILE_SUFFIX.length();
filename = filename.substring(0, newLength);
}
return encodeJobHistoryFileName(filename);
}
/** Since there was a restart, there should be a master file and
* a recovery file. Once the recovery is complete, the master should be
* deleted as an indication that the recovery file should be treated as the
* master upon completion or next restart.
* @param fileName the history filename that needs checkpointing
* @param conf Job conf
* @throws IOException
*/
static synchronized void checkpointRecovery(String fileName, JobConf conf)
throws IOException {
Path logPath = JobHistory.JobInfo.getJobHistoryLogLocation(fileName);
if (logPath != null) {
LOG.info("Deleting job history file " + logPath.getName());
LOGDIR_FS.delete(logPath, false);
}
// do the same for the user file too
logPath = JobHistory.JobInfo.getJobHistoryLogLocationForUser(fileName,
conf);
if (logPath != null) {
FileSystem fs = logPath.getFileSystem(conf);
fs.delete(logPath, false);
}
}
static String getSecondaryJobHistoryFile(String filename)
throws IOException {
return encodeJobHistoryFileName(
decodeJobHistoryFileName(filename) + SECONDARY_FILE_SUFFIX);
}
/** Selects one of the two files generated as a part of recovery.
* The thumb rule is that always select the oldest file.
* This call makes sure that only one file is left in the end.
* @param conf job conf
* @param logFilePath Path of the log file
* @throws IOException
*/
public synchronized static Path recoverJobHistoryFile(JobConf conf,
Path logFilePath)
throws IOException {
Path ret;
String logFileName = logFilePath.getName();
String tmpFilename = getSecondaryJobHistoryFile(logFileName);
Path logDir = logFilePath.getParent();
Path tmpFilePath = new Path(logDir, tmpFilename);
if (LOGDIR_FS.exists(logFilePath)) {
LOG.info(logFileName + " exists!");
if (LOGDIR_FS.exists(tmpFilePath)) {
LOG.info("Deleting " + tmpFilename
+ " and using " + logFileName + " for recovery.");
LOGDIR_FS.delete(tmpFilePath, false);
}
ret = tmpFilePath;
} else {
LOG.info(logFileName + " doesnt exist! Using "
+ tmpFilename + " for recovery.");
if (LOGDIR_FS.exists(tmpFilePath)) {
LOG.info("Renaming " + tmpFilename + " to " + logFileName);
LOGDIR_FS.rename(tmpFilePath, logFilePath);
ret = tmpFilePath;
} else {
ret = logFilePath;
}
}
// do the same for the user files too
logFilePath = getJobHistoryLogLocationForUser(logFileName, conf);
if (logFilePath != null) {
FileSystem fs = logFilePath.getFileSystem(conf);
logDir = logFilePath.getParent();
tmpFilePath = new Path(logDir, tmpFilename);
if (fs.exists(logFilePath)) {
LOG.info(logFileName + " exists!");
if (fs.exists(tmpFilePath)) {
LOG.info("Deleting " + tmpFilename + " and making " + logFileName
+ " as the master history file for user.");
fs.delete(tmpFilePath, false);
}
} else {
LOG.info(logFileName + " doesnt exist! Using "
+ tmpFilename + " as the master history file for user.");
if (fs.exists(tmpFilePath)) {
LOG.info("Renaming " + tmpFilename + " to " + logFileName
+ " in user directory");
fs.rename(tmpFilePath, logFilePath);
}
}
}
return ret;
}
/** Finalize the recovery and make one file in the end.
* This invloves renaming the recover file to the master file.
* Note that this api should be invoked only if recovery is involved.
* @param id Job id
* @param conf the job conf
* @throws IOException
*/
static synchronized void finalizeRecovery(JobID id, JobConf conf)
throws IOException {
Path tmpLogPath = fileManager.getHistoryFile(id);
if (tmpLogPath == null) {
if (LOG.isDebugEnabled()) {
LOG.debug("No file for job with " + id + " found in cache!");
}
return;
}
String tmpLogFileName = tmpLogPath.getName();
// get the primary filename from the cached filename
String masterLogFileName =
getPrimaryFilename(tmpLogFileName, getJobName(conf));
Path masterLogPath = new Path(tmpLogPath.getParent(), masterLogFileName);
// rename the tmp file to the master file. Note that this should be
// done only when the file is closed and handles are released.
LOG.info("Renaming " + tmpLogFileName + " to " + masterLogFileName);
LOGDIR_FS.rename(tmpLogPath, masterLogPath);
// update the cache
fileManager.setHistoryFile(id, masterLogPath);
// do the same for the user file too
masterLogPath =
JobHistory.JobInfo.getJobHistoryLogLocationForUser(masterLogFileName,
conf);
tmpLogPath =
JobHistory.JobInfo.getJobHistoryLogLocationForUser(tmpLogFileName,
conf);
if (masterLogPath != null) {
FileSystem fs = masterLogPath.getFileSystem(conf);
if (fs.exists(tmpLogPath)) {
LOG.info("Renaming " + tmpLogFileName + " to " + masterLogFileName
+ " in user directory");
fs.rename(tmpLogPath, masterLogPath);
}
}
}
/**
* Deletes job data from the local disk.
* For now just deletes the localized copy of job conf
*/
static void cleanupJob(JobID id) {
String localJobFilePath = JobInfo.getLocalJobFilePath(id);
File f = new File (localJobFilePath);
LOG.info("Deleting localized job conf at " + f);
if (!f.delete()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Failed to delete file " + f);
}
}
}
/**
* Delete job conf from the history folder.
*/
static void deleteConfFiles() throws IOException {
LOG.info("Cleaning up config files from the job history folder");
FileSystem fs = new Path(LOG_DIR).getFileSystem(jtConf);
FileStatus[] status = fs.listStatus(new Path(LOG_DIR), CONF_FILTER);
for (FileStatus s : status) {
LOG.info("Deleting conf file " + s.getPath());
fs.delete(s.getPath(), false);
}
}
/**
* Move the completed job into the completed folder.
* This assumes that the jobhistory file is closed and all operations on the
* jobhistory file is complete.
* This *should* be the last call to jobhistory for a given job.
*/
static void markCompleted(JobID id) throws IOException {
fileManager.moveToDone(id);
}
/**
* Log job submitted event to history. Creates a new file in history
* for the job. if history file creation fails, it disables history
* for all other events.
* @param jobId job id assigned by job tracker.
* @param jobConf job conf of the job
* @param jobConfPath path to job conf xml file in HDFS.
* @param submitTime time when job tracker received the job
* @throws IOException
* @deprecated Use
* {@link #logSubmitted(JobID, JobConf, String, long, boolean)} instead.
*/
@Deprecated
public static void logSubmitted(JobID jobId, JobConf jobConf,
String jobConfPath, long submitTime)
throws IOException {
logSubmitted(jobId, jobConf, jobConfPath, submitTime, true);
}
public static void logSubmitted(JobID jobId, JobConf jobConf,
String jobConfPath, long submitTime,
boolean restarted)
throws IOException {
FileSystem fs = null;
String userLogDir = null;
String jobUniqueString = jobId.toString();
// Get the username and job name to be used in the actual log filename;
// sanity check them too
String jobName = getJobName(jobConf);
String user = getUserName(jobConf);
// get the history filename
String logFileName = null;
if (restarted) {
logFileName = getJobHistoryFileName(jobConf, jobId);
if (logFileName == null) {
logFileName =
encodeJobHistoryFileName(getNewJobHistoryFileName
(jobConf, jobId, submitTime));
} else {
String parts[] = logFileName.split("_");
//TODO this is a hack :(
// jobtracker-hostname_jobtracker-identifier_
String jtUniqueString = parts[0] + "_" + parts[1] + "_";
jobUniqueString = jobId.toString();
}
} else {
logFileName =
encodeJobHistoryFileName(getNewJobHistoryFileName
(jobConf, jobId, submitTime));
}
// setup the history log file for this job
Path logFile = getJobHistoryLogLocation(logFileName);
// find user log directory
Path userLogFile =
getJobHistoryLogLocationForUser(logFileName, jobConf);
PrintWriter writer = null;
try{
FSDataOutputStream out = null;
if (LOG_DIR != null) {
// create output stream for logging in hadoop.job.history.location
if (restarted) {
logFile = recoverJobHistoryFile(jobConf, logFile);
logFileName = logFile.getName();
}
int defaultBufferSize =
LOGDIR_FS.getConf().getInt("io.file.buffer.size", 4096);
out = LOGDIR_FS.create(logFile,
new FsPermission(HISTORY_FILE_PERMISSION),
true,
defaultBufferSize,
LOGDIR_FS.getDefaultReplication(),
jobHistoryBlockSize, null);
writer = new PrintWriter(out);
fileManager.addWriter(jobId, writer);
// cache it ...
fileManager.setHistoryFile(jobId, logFile);
}
if (userLogFile != null) {
// Get the actual filename as recoverJobHistoryFile() might return
// a different filename
userLogDir = userLogFile.getParent().toString();
userLogFile = new Path(userLogDir, logFileName);
// create output stream for logging
// in hadoop.job.history.user.location
fs = userLogFile.getFileSystem(jobConf);
out = fs.create(userLogFile, true, 4096);
writer = new PrintWriter(out);
fileManager.addWriter(jobId, writer);
}
ArrayList<PrintWriter> writers = fileManager.getWriters(jobId);
// Log the history meta info
JobHistory.MetaInfoManager.logMetaInfo(writers);
String viewJobACL = "*";
String modifyJobACL = "*";
if (aclsEnabled) {
viewJobACL = jobConf.get(JobACL.VIEW_JOB.getAclName(), " ");
modifyJobACL = jobConf.get(JobACL.MODIFY_JOB.getAclName(), " ");
}
//add to writer as well
JobHistory.log(writers, RecordTypes.Job,
new Keys[]{Keys.JOBID, Keys.JOBNAME, Keys.USER,
Keys.SUBMIT_TIME, Keys.JOBCONF,
Keys.VIEW_JOB, Keys.MODIFY_JOB,
Keys.JOB_QUEUE},
new String[]{jobId.toString(), jobName, user,
String.valueOf(submitTime) , jobConfPath,
viewJobACL, modifyJobACL,
jobConf.getQueueName()}, jobId
);
}catch(IOException e){
LOG.error("Failed creating job history log file for job " + jobId, e);
if (writer != null) {
fileManager.removeWriter(jobId, writer);
}
}
// Always store job conf on local file system
String localJobFilePath = JobInfo.getLocalJobFilePath(jobId);
File localJobFile = new File(localJobFilePath);
FileOutputStream jobOut = null;
try {
jobOut = new FileOutputStream(localJobFile);
jobConf.writeXml(jobOut);
if (LOG.isDebugEnabled()) {
LOG.debug("Job conf for " + jobId + " stored at "
+ localJobFile.getAbsolutePath());
}
} catch (IOException ioe) {
LOG.error("Failed to store job conf on the local filesystem ", ioe);
} finally {
if (jobOut != null) {
try {
jobOut.close();
} catch (IOException ie) {
LOG.info("Failed to close the job configuration file "
+ StringUtils.stringifyException(ie));
}
}
}
/* Storing the job conf on the log dir */
Path jobFilePath = null;
if (LOG_DIR != null) {
jobFilePath = new Path(LOG_DIR + File.separator +
jobUniqueString + CONF_FILE_NAME_SUFFIX);
fileManager.setConfFile(jobId, jobFilePath);
}
Path userJobFilePath = null;
if (userLogDir != null) {
userJobFilePath = new Path(userLogDir + File.separator +
jobUniqueString + CONF_FILE_NAME_SUFFIX);
}
FSDataOutputStream jobFileOut = null;
try {
if (LOG_DIR != null) {
int defaultBufferSize =
LOGDIR_FS.getConf().getInt("io.file.buffer.size", 4096);
if (!LOGDIR_FS.exists(jobFilePath)) {
jobFileOut = LOGDIR_FS.create(jobFilePath,
new FsPermission(HISTORY_FILE_PERMISSION),
true,
defaultBufferSize,
LOGDIR_FS.getDefaultReplication(),
LOGDIR_FS.getDefaultBlockSize(), null);
jobConf.writeXml(jobFileOut);
jobFileOut.close();
}
}
if (userLogDir != null) {
fs = new Path(userLogDir).getFileSystem(jobConf);
jobFileOut = fs.create(userJobFilePath);
jobConf.writeXml(jobFileOut);
}
if (LOG.isDebugEnabled()) {
LOG.debug("Job conf for " + jobId + " stored at "
+ jobFilePath + "and" + userJobFilePath );
}
} catch (IOException ioe) {
LOG.error("Failed to store job conf in the log dir", ioe);
} finally {
if (jobFileOut != null) {
try {
jobFileOut.close();
} catch (IOException ie) {
LOG.info("Failed to close the job configuration file "
+ StringUtils.stringifyException(ie));
}
}
}
}
/**
* Logs launch time of job.
*
* @param jobId job id, assigned by jobtracker.
* @param startTime start time of job.
* @param totalMaps total maps assigned by jobtracker.
* @param totalReduces total reduces.
*/
public static void logInited(JobID jobId, long startTime,
int totalMaps, int totalReduces) {
ArrayList<PrintWriter> writer = fileManager.getWriters(jobId);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.LAUNCH_TIME, Keys.TOTAL_MAPS,
Keys.TOTAL_REDUCES, Keys.JOB_STATUS},
new String[] {jobId.toString(), String.valueOf(startTime),
String.valueOf(totalMaps),
String.valueOf(totalReduces),
Values.PREP.name()}, jobId);
}
}
/**
* Logs the job as RUNNING.
*
* @param jobId job id, assigned by jobtracker.
* @param startTime start time of job.
* @param totalMaps total maps assigned by jobtracker.
* @param totalReduces total reduces.
* @deprecated Use {@link #logInited(JobID, long, int, int)} and
* {@link #logStarted(JobID)}
*/
@Deprecated
public static void logStarted(JobID jobId, long startTime,
int totalMaps, int totalReduces) {
logStarted(jobId);
}
/**
* Logs job as running
* @param jobId job id, assigned by jobtracker.
*/
public static void logStarted(JobID jobId){
ArrayList<PrintWriter> writer = fileManager.getWriters(jobId);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.JOB_STATUS},
new String[] {jobId.toString(),
Values.RUNNING.name()}, jobId);
}
}
/**
* Log job finished. closes the job file in history.
* @param jobId job id, assigned by jobtracker.
* @param finishTime finish time of job in ms.
* @param finishedMaps no of maps successfully finished.
* @param finishedReduces no of reduces finished sucessfully.
* @param failedMaps no of failed map tasks.
* @param failedReduces no of failed reduce tasks.
* @param counters the counters from the job
*/
public static void logFinished(JobID jobId, long finishTime,
int finishedMaps, int finishedReduces,
int failedMaps, int failedReduces,
Counters mapCounters,
Counters reduceCounters,
Counters counters) {
// close job file for this job
ArrayList<PrintWriter> writer = fileManager.getWriters(jobId);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.FINISH_TIME,
Keys.JOB_STATUS, Keys.FINISHED_MAPS,
Keys.FINISHED_REDUCES,
Keys.FAILED_MAPS, Keys.FAILED_REDUCES,
Keys.MAP_COUNTERS, Keys.REDUCE_COUNTERS,
Keys.COUNTERS},
new String[] {jobId.toString(), Long.toString(finishTime),
Values.SUCCESS.name(),
String.valueOf(finishedMaps),
String.valueOf(finishedReduces),
String.valueOf(failedMaps),
String.valueOf(failedReduces),
mapCounters.makeEscapedCompactString(),
reduceCounters.makeEscapedCompactString(),
counters.makeEscapedCompactString()}, jobId);
for (PrintWriter out : writer) {
out.close();
}
}
Thread historyCleaner = new Thread(new HistoryCleaner());
historyCleaner.start();
}
/**
* Logs job failed event. Closes the job history log file.
* @param jobid job id
* @param timestamp time when job failure was detected in ms.
* @param finishedMaps no finished map tasks.
* @param finishedReduces no of finished reduce tasks.
*/
public static void logFailed(JobID jobid, long timestamp, int finishedMaps, int finishedReduces, String failReason){
ArrayList<PrintWriter> writer = fileManager.getWriters(jobid);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.FINISH_TIME, Keys.JOB_STATUS, Keys.FINISHED_MAPS, Keys.FINISHED_REDUCES, Keys.FAIL_REASON },
new String[] {jobid.toString(), String.valueOf(timestamp), Values.FAILED.name(), String.valueOf(finishedMaps),
String.valueOf(finishedReduces), failReason}, jobid);
for (PrintWriter out : writer) {
out.close();
}
}
}
/**
* Logs job killed event. Closes the job history log file.
*
* @param jobid
* job id
* @param timestamp
* time when job killed was issued in ms.
* @param finishedMaps
* no finished map tasks.
* @param finishedReduces
* no of finished reduce tasks.
*/
public static void logKilled(JobID jobid, long timestamp, int finishedMaps,
int finishedReduces) {
ArrayList<PrintWriter> writer = fileManager.getWriters(jobid);
if (null != writer) {
JobHistory.log(writer, RecordTypes.Job, new Keys[] { Keys.JOBID,
Keys.FINISH_TIME, Keys.JOB_STATUS, Keys.FINISHED_MAPS,
Keys.FINISHED_REDUCES }, new String[] { jobid.toString(),
String.valueOf(timestamp), Values.KILLED.name(),
String.valueOf(finishedMaps), String.valueOf(finishedReduces) }, jobid);
for (PrintWriter out : writer) {
out.close();
}
}
}
/**
* Log job's priority.
* @param jobid job id
* @param priority Jobs priority
*/
public static void logJobPriority(JobID jobid, JobPriority priority){
ArrayList<PrintWriter> writer = fileManager.getWriters(jobid);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.JOB_PRIORITY},
new String[] {jobid.toString(), priority.toString()}, jobid);
}
}
/**
* Log job's submit-time/launch-time
* @param jobid job id
* @param submitTime job's submit time
* @param launchTime job's launch time
* @param restartCount number of times the job got restarted
* @deprecated Use {@link #logJobInfo(JobID, long, long)} instead.
*/
@Deprecated
public static void logJobInfo(JobID jobid, long submitTime, long launchTime,
int restartCount){
logJobInfo(jobid, submitTime, launchTime);
}
public static void logJobInfo(JobID jobid, long submitTime, long launchTime)
{
ArrayList<PrintWriter> writer = fileManager.getWriters(jobid);
if (null != writer){
JobHistory.log(writer, RecordTypes.Job,
new Keys[] {Keys.JOBID, Keys.SUBMIT_TIME,
Keys.LAUNCH_TIME},
new String[] {jobid.toString(),
String.valueOf(submitTime),
String.valueOf(launchTime)}, jobid);
}
}
}
/**
* Helper class for logging or reading back events related to Task's start, finish or failure.
* All events logged by this class are logged in a separate file per job in
* job tracker history. These events map to TIPs in jobtracker.
*/
public static class Task extends KeyValuePair{
private Map <String, TaskAttempt> taskAttempts = new TreeMap<String, TaskAttempt>();
/**
* Log start time of task (TIP).
* @param taskId task id
* @param taskType MAP or REDUCE
* @param startTime startTime of tip.
*/
public static void logStarted(TaskID taskId, String taskType,
long startTime, String splitLocations) {
JobID id = taskId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.Task,
new Keys[]{Keys.TASKID, Keys.TASK_TYPE ,
Keys.START_TIME, Keys.SPLITS},
new String[]{taskId.toString(), taskType,
String.valueOf(startTime),
splitLocations}, id);
}
}
/**
* Log finish time of task.
* @param taskId task id
* @param taskType MAP or REDUCE
* @param finishTime finish timeof task in ms
*/
public static void logFinished(TaskID taskId, String taskType,
long finishTime, Counters counters){
JobID id = taskId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.Task,
new Keys[]{Keys.TASKID, Keys.TASK_TYPE,
Keys.TASK_STATUS, Keys.FINISH_TIME,
Keys.COUNTERS},
new String[]{ taskId.toString(), taskType, Values.SUCCESS.name(),
String.valueOf(finishTime),
counters.makeEscapedCompactString()}, id);
}
}
/**
* Update the finish time of task.
* @param taskId task id
* @param finishTime finish time of task in ms
*/
public static void logUpdates(TaskID taskId, long finishTime){
JobID id = taskId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.Task,
new Keys[]{Keys.TASKID, Keys.FINISH_TIME},
new String[]{ taskId.toString(),
String.valueOf(finishTime)}, id);
}
}
/**
* Log job failed event.
* @param taskId task id
* @param taskType MAP or REDUCE.
* @param time timestamp when job failed detected.
* @param error error message for failure.
*/
public static void logFailed(TaskID taskId, String taskType, long time, String error){
logFailed(taskId, taskType, time, error, null);
}
/**
* @param failedDueToAttempt The attempt that caused the failure, if any
*/
public static void logFailed(TaskID taskId, String taskType, long time,
String error,
TaskAttemptID failedDueToAttempt){
JobID id = taskId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
String failedAttempt = failedDueToAttempt == null
? ""
: failedDueToAttempt.toString();
JobHistory.log(writer, RecordTypes.Task,
new Keys[]{Keys.TASKID, Keys.TASK_TYPE,
Keys.TASK_STATUS, Keys.FINISH_TIME,
Keys.ERROR, Keys.TASK_ATTEMPT_ID},
new String[]{ taskId.toString(), taskType,
Values.FAILED.name(),
String.valueOf(time) , error,
failedAttempt}, id);
}
}
/**
* Returns all task attempts for this task. <task attempt id - TaskAttempt>
*/
public Map<String, TaskAttempt> getTaskAttempts(){
return this.taskAttempts;
}
}
/**
* Base class for Map and Reduce TaskAttempts.
*/
public static class TaskAttempt extends Task{}
/**
* Helper class for logging or reading back events related to start, finish or failure of
* a Map Attempt on a node.
*/
public static class MapAttempt extends TaskAttempt{
/**
* Log start time of this map task attempt.
* @param taskAttemptId task attempt id
* @param startTime start time of task attempt as reported by task tracker.
* @param hostName host name of the task attempt.
* @deprecated Use
* {@link #logStarted(TaskAttemptID, long, String, int, String)}
*/
@Deprecated
public static void logStarted(TaskAttemptID taskAttemptId, long startTime, String hostName){
logStarted(taskAttemptId, startTime, hostName, -1, Values.MAP.name());
}
/**
* Log start time of this map task attempt.
*
* @param taskAttemptId task attempt id
* @param startTime start time of task attempt as reported by task tracker.
* @param trackerName name of the tracker executing the task attempt.
* @param httpPort http port of the task tracker executing the task attempt
* @param taskType Whether the attempt is cleanup or setup or map
*/
public static void logStarted(TaskAttemptID taskAttemptId, long startTime,
String trackerName, int httpPort,
String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.MapAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.START_TIME,
Keys.TRACKER_NAME, Keys.HTTP_PORT},
new String[]{taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
String.valueOf(startTime), trackerName,
httpPort == -1 ? "" :
String.valueOf(httpPort)}, id);
}
}
/**
* Log finish time of map task attempt.
* @param taskAttemptId task attempt id
* @param finishTime finish time
* @param hostName host name
* @deprecated Use
* {@link #logFinished(TaskAttemptID, long, String, String, String, Counters)}
*/
@Deprecated
public static void logFinished(TaskAttemptID taskAttemptId, long finishTime,
String hostName){
logFinished(taskAttemptId, finishTime, hostName, Values.MAP.name(), "",
new Counters());
}
/**
* Log finish time of map task attempt.
*
* @param taskAttemptId task attempt id
* @param finishTime finish time
* @param hostName host name
* @param taskType Whether the attempt is cleanup or setup or map
* @param stateString state string of the task attempt
* @param counter counters of the task attempt
*/
public static void logFinished(TaskAttemptID taskAttemptId,
long finishTime,
String hostName,
String taskType,
String stateString,
Counters counter) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.MapAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.FINISH_TIME, Keys.HOSTNAME,
Keys.STATE_STRING, Keys.COUNTERS},
new String[]{taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.SUCCESS.name(),
String.valueOf(finishTime), hostName,
stateString,
counter.makeEscapedCompactString()}, id);
}
}
/**
* Log task attempt failed event.
* @param taskAttemptId task attempt id
* @param timestamp timestamp
* @param hostName hostname of this task attempt.
* @param error error message if any for this task attempt.
* @deprecated Use
* {@link #logFailed(TaskAttemptID, long, String, String, String)}
*/
@Deprecated
public static void logFailed(TaskAttemptID taskAttemptId,
long timestamp, String hostName,
String error) {
logFailed(taskAttemptId, timestamp, hostName, error, Values.MAP.name());
}
/**
* Log task attempt failed event.
*
* @param taskAttemptId task attempt id
* @param timestamp timestamp
* @param hostName hostname of this task attempt.
* @param error error message if any for this task attempt.
* @param taskType Whether the attempt is cleanup or setup or map
*/
public static void logFailed(TaskAttemptID taskAttemptId,
long timestamp, String hostName,
String error, String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.MapAttempt,
new Keys[]{Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.FINISH_TIME, Keys.HOSTNAME, Keys.ERROR},
new String[]{ taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.FAILED.name(),
String.valueOf(timestamp),
hostName, error}, id);
}
}
/**
* Log task attempt killed event.
* @param taskAttemptId task attempt id
* @param timestamp timestamp
* @param hostName hostname of this task attempt.
* @param error error message if any for this task attempt.
* @deprecated Use
* {@link #logKilled(TaskAttemptID, long, String, String, String)}
*/
@Deprecated
public static void logKilled(TaskAttemptID taskAttemptId,
long timestamp, String hostName, String error){
logKilled(taskAttemptId, timestamp, hostName, error, Values.MAP.name());
}
/**
* Log task attempt killed event.
*
* @param taskAttemptId task attempt id
* @param timestamp timestamp
* @param hostName hostname of this task attempt.
* @param error error message if any for this task attempt.
* @param taskType Whether the attempt is cleanup or setup or map
*/
public static void logKilled(TaskAttemptID taskAttemptId,
long timestamp, String hostName,
String error, String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.MapAttempt,
new Keys[]{Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.FINISH_TIME, Keys.HOSTNAME,
Keys.ERROR},
new String[]{ taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.KILLED.name(),
String.valueOf(timestamp),
hostName, error}, id);
}
}
}
/**
* Helper class for logging or reading back events related to start, finish or failure of
* a Map Attempt on a node.
*/
public static class ReduceAttempt extends TaskAttempt{
/**
* Log start time of Reduce task attempt.
* @param taskAttemptId task attempt id
* @param startTime start time
* @param hostName host name
* @deprecated Use
* {@link #logStarted(TaskAttemptID, long, String, int, String)}
*/
@Deprecated
public static void logStarted(TaskAttemptID taskAttemptId,
long startTime, String hostName){
logStarted(taskAttemptId, startTime, hostName, -1, Values.REDUCE.name());
}
/**
* Log start time of Reduce task attempt.
*
* @param taskAttemptId task attempt id
* @param startTime start time
* @param trackerName tracker name
* @param httpPort the http port of the tracker executing the task attempt
* @param taskType Whether the attempt is cleanup or setup or reduce
*/
public static void logStarted(TaskAttemptID taskAttemptId,
long startTime, String trackerName,
int httpPort,
String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.ReduceAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.START_TIME,
Keys.TRACKER_NAME, Keys.HTTP_PORT},
new String[]{taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
String.valueOf(startTime), trackerName,
httpPort == -1 ? "" :
String.valueOf(httpPort)}, id);
}
}
/**
* Log finished event of this task.
* @param taskAttemptId task attempt id
* @param shuffleFinished shuffle finish time
* @param sortFinished sort finish time
* @param finishTime finish time of task
* @param hostName host name where task attempt executed
* @deprecated Use
* {@link #logFinished(TaskAttemptID, long, long, long, String, String, String, Counters)}
*/
@Deprecated
public static void logFinished(TaskAttemptID taskAttemptId, long shuffleFinished,
long sortFinished, long finishTime,
String hostName){
logFinished(taskAttemptId, shuffleFinished, sortFinished,
finishTime, hostName, Values.REDUCE.name(),
"", new Counters());
}
/**
* Log finished event of this task.
*
* @param taskAttemptId task attempt id
* @param shuffleFinished shuffle finish time
* @param sortFinished sort finish time
* @param finishTime finish time of task
* @param hostName host name where task attempt executed
* @param taskType Whether the attempt is cleanup or setup or reduce
* @param stateString the state string of the attempt
* @param counter counters of the attempt
*/
public static void logFinished(TaskAttemptID taskAttemptId,
long shuffleFinished,
long sortFinished, long finishTime,
String hostName, String taskType,
String stateString, Counters counter) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.ReduceAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.SHUFFLE_FINISHED, Keys.SORT_FINISHED,
Keys.FINISH_TIME, Keys.HOSTNAME,
Keys.STATE_STRING, Keys.COUNTERS},
new String[]{taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.SUCCESS.name(),
String.valueOf(shuffleFinished),
String.valueOf(sortFinished),
String.valueOf(finishTime), hostName,
stateString,
counter.makeEscapedCompactString()}, id);
}
}
/**
* Log failed reduce task attempt.
* @param taskAttemptId task attempt id
* @param timestamp time stamp when task failed
* @param hostName host name of the task attempt.
* @param error error message of the task.
* @deprecated Use
* {@link #logFailed(TaskAttemptID, long, String, String, String)}
*/
@Deprecated
public static void logFailed(TaskAttemptID taskAttemptId, long timestamp,
String hostName, String error){
logFailed(taskAttemptId, timestamp, hostName, error, Values.REDUCE.name());
}
/**
* Log failed reduce task attempt.
*
* @param taskAttemptId task attempt id
* @param timestamp time stamp when task failed
* @param hostName host name of the task attempt.
* @param error error message of the task.
* @param taskType Whether the attempt is cleanup or setup or reduce
*/
public static void logFailed(TaskAttemptID taskAttemptId, long timestamp,
String hostName, String error,
String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.ReduceAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.FINISH_TIME, Keys.HOSTNAME,
Keys.ERROR },
new String[]{ taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.FAILED.name(),
String.valueOf(timestamp), hostName, error }, id);
}
}
/**
* Log killed reduce task attempt.
* @param taskAttemptId task attempt id
* @param timestamp time stamp when task failed
* @param hostName host name of the task attempt.
* @param error error message of the task.
* @deprecated Use
* {@link #logKilled(TaskAttemptID, long, String, String, String)}
*/
@Deprecated
public static void logKilled(TaskAttemptID taskAttemptId, long timestamp,
String hostName, String error) {
logKilled(taskAttemptId, timestamp, hostName, error, Values.REDUCE.name());
}
/**
* Log killed reduce task attempt.
*
* @param taskAttemptId task attempt id
* @param timestamp time stamp when task failed
* @param hostName host name of the task attempt.
* @param error error message of the task.
* @param taskType Whether the attempt is cleanup or setup or reduce
*/
public static void logKilled(TaskAttemptID taskAttemptId, long timestamp,
String hostName, String error,
String taskType) {
JobID id = taskAttemptId.getJobID();
ArrayList<PrintWriter> writer = fileManager.getWriters(id);
if (null != writer){
JobHistory.log(writer, RecordTypes.ReduceAttempt,
new Keys[]{ Keys.TASK_TYPE, Keys.TASKID,
Keys.TASK_ATTEMPT_ID, Keys.TASK_STATUS,
Keys.FINISH_TIME, Keys.HOSTNAME,
Keys.ERROR },
new String[]{ taskType,
taskAttemptId.getTaskID().toString(),
taskAttemptId.toString(),
Values.KILLED.name(),
String.valueOf(timestamp),
hostName, error }, id);
}
}
}
/**
* Callback interface for reading back log events from JobHistory. This interface
* should be implemented and passed to JobHistory.parseHistory()
*
*/
public static interface Listener{
/**
* Callback method for history parser.
* @param recType type of record, which is the first entry in the line.
* @param values a map of key-value pairs as thry appear in history.
* @throws IOException
*/
public void handle(RecordTypes recType, Map<Keys, String> values) throws IOException;
}
static long directoryTime(String year, String seg2, String seg3) {
// set to current time. In debug mode, this is where the month
// and day get set.
Calendar result = Calendar.getInstance();
// canonicalize by filling in unset fields
result.setTimeInMillis(System.currentTimeMillis());
result.set(Calendar.YEAR, Integer.parseInt(year));
// months are 0-based in Calendar, but people will expect January
// to be month #1 . Therefore the number is bumped before we make the
// directory name and must be debumped to seek the time.
result.set(DEBUG_MODE ? Calendar.HOUR : Calendar.MONTH,
Integer.parseInt(seg2) - 1);
result.set(DEBUG_MODE ? Calendar.MINUTE : Calendar.DAY_OF_MONTH,
Integer.parseInt(seg3));
return result.getTimeInMillis();
}
/**
* Delete history files older than one month. Update master index and remove all
* jobs older than one month. Also if a job tracker has no jobs in last one month
* remove reference to the job tracker.
*
*/
public static class HistoryCleaner implements Runnable {
static final long ONE_DAY_IN_MS = 24 * 60 * 60 * 1000L;
static final long DIRECTORY_LIFE_IN_MS
= DEBUG_MODE ? 20 * 60 * 1000L : 30 * ONE_DAY_IN_MS;
static final long RUN_INTERVAL
= DEBUG_MODE ? 10L * 60L * 1000L : ONE_DAY_IN_MS;
private long now;
private static final AtomicBoolean isRunning = new AtomicBoolean(false);
private static long lastRan = 0;
private static Pattern parseDirectory
= Pattern.compile(".+/([0-9]+)/([0-9]+)/([0-9]+)/[0-9]+/?");
/**
* Cleans up history data.
*/
public void run() {
if (isRunning.getAndSet(true)) {
return;
}
now = System.currentTimeMillis();
// clean history only once a day at max
if (lastRan != 0 && (now - lastRan) < RUN_INTERVAL) {
isRunning.set(false);
return;
}
lastRan = now;
Set<String> deletedPathnames = new HashSet<String>();
// XXXXX debug code
boolean printedOneDeletee = false;
boolean printedOneMovedFile = false;
try {
Path[] datedDirectories
= FileUtil.stat2Paths(localGlobber(DONEDIR_FS, DONE,
DONE_BEFORE_SERIAL_TAIL, null));
// find directories older than 30 days
for (int i = 0; i < datedDirectories.length; ++i) {
String thisDir = datedDirectories[i].toString();
Matcher pathMatcher = parseDirectory.matcher(thisDir);
if (pathMatcher.matches()) {
long dirTime = directoryTime(pathMatcher.group(1),
pathMatcher.group(2),
pathMatcher.group(3));
if (DEBUG_MODE) {
System.err.println("HistoryCleaner.run just parsed " + thisDir
+ " as year/month/day = " + pathMatcher.group(1)
+ "/" + pathMatcher.group(2) + "/"
+ pathMatcher.group(3));
}
if (dirTime < now - DIRECTORY_LIFE_IN_MS) {
if (DEBUG_MODE) {
Calendar then = Calendar.getInstance();
then.setTimeInMillis(dirTime);
Calendar nnow = Calendar.getInstance();
nnow.setTimeInMillis(now);
System.err.println("HistoryCleaner.run directory: " + thisDir
+ " because its time is " + then
+ " but it's now " + nnow);
System.err.println("then = " + dirTime);
System.err.println("now = " + now);
}
// remove every file in the directory and save the name
// so we can remove it from jobHistoryFileMap
Path[] deletees
= FileUtil.stat2Paths(localGlobber(DONEDIR_FS,
datedDirectories[i],
"/*/*", // sn + individual files
null));
for (int j = 0; j < deletees.length; ++j) {
if (DEBUG_MODE && !printedOneDeletee) {
System.err.println("HistoryCleaner.run deletee: " + deletees[j].toString());
printedOneDeletee = true;
}
DONEDIR_FS.delete(deletees[j]);
deletedPathnames.add(deletees[j].toString());
}
synchronized (existingDoneSubdirs) {
if (!existingDoneSubdirs.contains(datedDirectories[i]))
{
LOG.warn("JobHistory: existingDoneSubdirs doesn't contain "
+ datedDirectories[i] + ", but should.");
}
DONEDIR_FS.delete(datedDirectories[i], true);
existingDoneSubdirs.remove(datedDirectories[i]);
}
}
}
}
//walking over the map to purge entries from jobHistoryFileMap
synchronized (jobHistoryFileMap) {
Iterator<Entry<JobID, MovedFileInfo>> it =
jobHistoryFileMap.entrySet().iterator();
while (it.hasNext()) {
MovedFileInfo info = it.next().getValue();
if (DEBUG_MODE && !printedOneMovedFile) {
System.err.println("HistoryCleaner.run a moved file: " + info.historyFile);
printedOneMovedFile = true;
}
if (deletedPathnames.contains(info.historyFile)) {
it.remove();
}
}
}
} catch (IOException ie) {
LOG.info("Error cleaning up history directory" +
StringUtils.stringifyException(ie));
} finally {
isRunning.set(false);
}
}
static long getLastRan() {
return lastRan;
}
}
/**
* Return the TaskLogsUrl of a particular TaskAttempt
*
* @param attempt
* @return the taskLogsUrl. null if http-port or tracker-name or
* task-attempt-id are unavailable.
*/
public static String getTaskLogsUrl(JobHistory.TaskAttempt attempt) {
if (attempt.get(Keys.HTTP_PORT).equals("")
|| attempt.get(Keys.TRACKER_NAME).equals("")
|| attempt.get(Keys.TASK_ATTEMPT_ID).equals("")) {
return null;
}
String taskTrackerName =
JobInProgress.convertTrackerNameToHostName(
attempt.get(Keys.TRACKER_NAME));
return TaskLogServlet.getTaskLogUrl(taskTrackerName, attempt
.get(Keys.HTTP_PORT), attempt.get(Keys.TASK_ATTEMPT_ID));
}
}
| [
"[email protected]"
] | |
32238bc98598af1f76a0a9db2903da73d33485fb | ef40b039fdad42ff152771b3050a258e3dd7e76d | /src/main/java/com/example/demo/jvm/Jclen.java | 9a73e5a49767e0727ca74402919b9356ef9869f9 | [] | no_license | xchnba/spring_boot_mybits | 0ac950aefe57db3fe7037f1bc59cf6b082c6ae29 | 99576b94396ab4ab5b730db663fd29dc51c0f78d | refs/heads/master | 2022-07-05T18:55:37.088115 | 2020-10-19T14:24:43 | 2020-10-19T14:24:43 | 223,743,669 | 3 | 1 | null | 2022-06-21T02:18:22 | 2019-11-24T12:52:54 | Java | UTF-8 | Java | false | false | 1,357 | java | package com.example.demo.jvm;
import com.example.demo.mall.domain.Student;
import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.info.GraphLayout;
public class Jclen {
private int a = 123;
private Student student;
private String b = "abc10感觉20";
public static void main(String[] args) {
// Object obj = generate();
Jclen jc = new Jclen();
// jc.add();
// String e ="haha";
//查看对象内部信息
// System.out.println((ClassLayout.parseInstance(jc).toPrintable()));
//查看对象内部信息
System.out.println(ClassLayout.parseInstance(jc).toPrintable());
//查看对象外部信息
System.out.println(GraphLayout.parseInstance(jc).toPrintable());
//获取对象总大小
System.out.println("size : " + GraphLayout.parseInstance(jc).totalSize());
// System.out.println(e);
}
// static Object generate() {
// Map<String, Object> map = new HashMap<>();
// map.put("a", new Integer(1));
// map.put("b", "b");
// map.put("c", new Date());
//
// for (int i = 0; i < 10; i++) {
// map.put(String.valueOf(i), String.valueOf(i));
// }
// return map;
// }
// int add(){
// int d = 4;
// int c = 3;
// return d+c;
// }
}
| [
"[email protected]"
] | |
9c3e59d63d4be812c758066216317ab9d50ad310 | 91ea44cbab592d7404e1f9286e3043b61e253210 | /db-common/src/main/java/com/shawn/ss/lib/tools/service_assemble/AbstractDaoAssembler.java | 4ff4f91d235fa12325b94479482d9d4716a8a044 | [] | no_license | seastar-ss/gt_code | 9fb880dd9846b12de9b89ce72753b4790a4063e8 | aaf731e4e0492ba7a558db494f42ebfb27706b1a | refs/heads/master | 2022-12-25T08:46:55.535292 | 2021-03-20T14:45:47 | 2021-03-20T14:45:47 | 212,599,031 | 0 | 0 | null | 2022-12-16T10:32:33 | 2019-10-03T14:20:16 | Java | UTF-8 | Java | false | false | 1,555 | java | package com.shawn.ss.lib.tools.service_assemble;
import com.shawn.ss.lib.tools.db.api.interfaces.db_operation.dao.model.DataSourceAndSchemaAndTable;
import com.shawn.ss.lib.tools.db.api.interfaces.mappers.db.DbResultSetMapper;
import com.shawn.ss.lib.tools.db.dto_base.model.AbstractBaseModel;
import com.shawn.ss.lib.tools.sql_code_gen.api.SQL;
import java.util.List;
import java.util.Map;
/**
* Created by ss on 2018/10/5.
*/
public abstract class AbstractDaoAssembler implements DaoAssembler {
protected final boolean isMultiple;
protected AbstractDaoAssembler(boolean isMultiple){
this.isMultiple = isMultiple;
}
@Override
public int assembleSql(SQL sql, Map<String, Object> params, Class<? extends AbstractBaseModel> tClazz) {
return 0;
}
@Override
public int assembleSql(SQL sql, List<Map<String, Object>> params, Class<? extends AbstractBaseModel> tClazz) {
return 0;
}
@Override
public <T extends AbstractBaseModel> DbResultSetMapper<T> assembleResultSetMapper(Map<String, Object> params, Class<T> tClazz) {
return null;
}
@Override
public DataSourceAndSchemaAndTable selectDb(SQL sql, Map<String, Object> params, Class<? extends AbstractBaseModel> tClazz) {
return null;
}
@Override
public DataSourceAndSchemaAndTable selectDb(SQL sql, List<Map<String, Object>> params, Class<? extends AbstractBaseModel> tClazz) {
return null;
}
@Override
public boolean isMultiple() {
return isMultiple;
}
}
| [
"[email protected]"
] | |
e5cbeddd24b98f2670f28c8eb8285133aac7902b | 1dd707843665c6a8c7656ee596d09a3c919cb810 | /HelloWorldTriangle/app/src/main/java/gles/cookbook/helloworldtriangle/GLESView.java | 23df9e5d0ac6d78b5351c606c426287721c15660 | [] | no_license | xtrimzz/OpenGLES3-Android-NDK | 83c2d9e7ef6651c961a729e82077da786192ecfa | 98b53d167a1bf8e14caf186f1b3e3c4625e72fdb | refs/heads/master | 2020-05-01T09:41:43.562543 | 2019-03-24T13:18:17 | 2019-03-24T13:18:17 | 177,405,983 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,735 | java | package gles.cookbook.helloworldtriangle;
import android.content.Context;
import android.graphics.PixelFormat;
import android.opengl.GLSurfaceView;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.opengles.GL10;
/**
* A simple GLSurfaceView sub-class that demonstrate how to perform
* OpenGL ES 3.0 rendering into a GL Surface. Note the following important
* details:
*
* - The class must use a custom context factory to enable 3.0 rendering.
* See ContextFactory class definition below.
*
* - The class must use a custom EGLConfigChooser to be able to select
* an EGLConfig that supports 3.0. This is done by providing a config
* specification to eglChooseConfig() that has the attribute
* EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
* set. See ConfigChooser class definition below.
*
* - The class must select the surface's format, then choose an EGLConfig
* that matches it exactly (with regards to red/green/blue/alpha channels
* bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
*/
class GLESView extends GLSurfaceView {
private static String TAG = "GLESView";
private static final boolean DEBUG = false;
public GLESView(Context context) {
super(context);
init(false, 0, 0, context.getPackageResourcePath());
}
public GLESView(Context context, boolean translucent, int depth, int stencil) {
super(context);
init(translucent, depth, stencil, context.getPackageResourcePath());
}
private void init(boolean translucent, int depth, int stencil, String filePathArg) {
/* By default, GLSurfaceView() creates a RGB_565 opaque surface.
* If we want a translucent one, we should change the surface's
* format here, using PixelFormat.TRANSLUCENT for GL Surfaces
* is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
*/
if (translucent) {
this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
}
/* Set our custom context factory class object.
*/
setEGLContextFactory(new ContextFactory());
/* Choose the EGLConfig that matches the format of
* our surface and set this configuration to EGL.
*/
setEGLConfigChooser( translucent ?
new ConfigChooser(8, 8, 8, 8, depth, stencil) :
new ConfigChooser(5, 6, 5, 0, depth, stencil) );
/* Set the renderer responsible for frame rendering */
Renderer rendererObj = new Renderer();
rendererObj.filePath = filePathArg;
setRenderer(rendererObj);
}
private static double glVersion = 3.0;
private static class ContextFactory implements EGLContextFactory {
private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
Log.w(TAG, "creating OpenGL ES 3.0 context");
checkEglError("Before eglCreateContext", egl);
int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, (int)glVersion, EGL10.EGL_NONE };
EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
checkEglError("After eglCreateContext", egl);
return context;// returns null if 3.0 is not supported;
}
public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
egl.eglDestroyContext(display, context);
}
}
private static void checkEglError(String prompt, EGL10 egl) {
int error;
while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
}
}
private static class ConfigChooser implements EGLConfigChooser {
public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
mRedSize = r;
mGreenSize = g;
mBlueSize = b;
mAlphaSize = a;
mDepthSize = depth;
mStencilSize = stencil;
}
/* This EGL config specification is used to specify 3.0 rendering.
* We use a minimum size of 4 bits for red/green/blue, but will
* perform actual matching in chooseConfig() below.
*/
private static int EGL_OPENGL_ES2_BIT = 4;
private static int[] s_configAttribs2 =
{
EGL10.EGL_RED_SIZE, 4,
EGL10.EGL_GREEN_SIZE, 4,
EGL10.EGL_BLUE_SIZE, 4,
EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL10.EGL_NONE
};
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
/* Get the number of minimally matching EGL configurations
*/
int[] num_config = new int[1];
egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
int numConfigs = num_config[0];
if (numConfigs <= 0) {
throw new IllegalArgumentException("No configs match configSpec");
}
/* Allocate then read the array of minimally matching EGL configs
*/
EGLConfig[] configs = new EGLConfig[numConfigs];
egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
if (DEBUG) {
printConfigs(egl, display, configs);
}
/* Now return the "best" one
*/
return chooseConfig(egl, display, configs);
}
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
EGLConfig[] configs) {
for(EGLConfig config : configs) {
int d = findConfigAttrib(egl, display, config,
EGL10.EGL_DEPTH_SIZE, 0);
int s = findConfigAttrib(egl, display, config,
EGL10.EGL_STENCIL_SIZE, 0);
// We need at least mDepthSize and mStencilSize bits
if (d < mDepthSize || s < mStencilSize)
continue;
// We want an *exact* match for red/green/blue/alpha
int r = findConfigAttrib(egl, display, config,
EGL10.EGL_RED_SIZE, 0);
int g = findConfigAttrib(egl, display, config,
EGL10.EGL_GREEN_SIZE, 0);
int b = findConfigAttrib(egl, display, config,
EGL10.EGL_BLUE_SIZE, 0);
int a = findConfigAttrib(egl, display, config,
EGL10.EGL_ALPHA_SIZE, 0);
if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
return config;
}
return null;
}
private int findConfigAttrib(EGL10 egl, EGLDisplay display,
EGLConfig config, int attribute, int defaultValue) {
if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
return mValue[0];
}
return defaultValue;
}
private void printConfigs(EGL10 egl, EGLDisplay display,
EGLConfig[] configs) {
int numConfigs = configs.length;
Log.w(TAG, String.format("%d configurations", numConfigs));
for (int i = 0; i < numConfigs; i++) {
Log.w(TAG, String.format("Configuration %d:\n", i));
printConfig(egl, display, configs[i]);
}
}
private void printConfig(EGL10 egl, EGLDisplay display,
EGLConfig config) {
int[] attributes = {
EGL10.EGL_BUFFER_SIZE,
EGL10.EGL_ALPHA_SIZE,
EGL10.EGL_BLUE_SIZE,
EGL10.EGL_GREEN_SIZE,
EGL10.EGL_RED_SIZE,
EGL10.EGL_DEPTH_SIZE,
EGL10.EGL_STENCIL_SIZE,
EGL10.EGL_CONFIG_CAVEAT,
EGL10.EGL_CONFIG_ID,
EGL10.EGL_LEVEL,
EGL10.EGL_MAX_PBUFFER_HEIGHT,
EGL10.EGL_MAX_PBUFFER_PIXELS,
EGL10.EGL_MAX_PBUFFER_WIDTH,
EGL10.EGL_NATIVE_RENDERABLE,
EGL10.EGL_NATIVE_VISUAL_ID,
EGL10.EGL_NATIVE_VISUAL_TYPE,
0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
EGL10.EGL_SAMPLES,
EGL10.EGL_SAMPLE_BUFFERS,
EGL10.EGL_SURFACE_TYPE,
EGL10.EGL_TRANSPARENT_TYPE,
EGL10.EGL_TRANSPARENT_RED_VALUE,
EGL10.EGL_TRANSPARENT_GREEN_VALUE,
EGL10.EGL_TRANSPARENT_BLUE_VALUE,
0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
EGL10.EGL_LUMINANCE_SIZE,
EGL10.EGL_ALPHA_MASK_SIZE,
EGL10.EGL_COLOR_BUFFER_TYPE,
EGL10.EGL_RENDERABLE_TYPE,
0x3042 // EGL10.EGL_CONFORMANT
};
String[] names = {
"EGL_BUFFER_SIZE",
"EGL_ALPHA_SIZE",
"EGL_BLUE_SIZE",
"EGL_GREEN_SIZE",
"EGL_RED_SIZE",
"EGL_DEPTH_SIZE",
"EGL_STENCIL_SIZE",
"EGL_CONFIG_CAVEAT",
"EGL_CONFIG_ID",
"EGL_LEVEL",
"EGL_MAX_PBUFFER_HEIGHT",
"EGL_MAX_PBUFFER_PIXELS",
"EGL_MAX_PBUFFER_WIDTH",
"EGL_NATIVE_RENDERABLE",
"EGL_NATIVE_VISUAL_ID",
"EGL_NATIVE_VISUAL_TYPE",
"EGL_PRESERVED_RESOURCES",
"EGL_SAMPLES",
"EGL_SAMPLE_BUFFERS",
"EGL_SURFACE_TYPE",
"EGL_TRANSPARENT_TYPE",
"EGL_TRANSPARENT_RED_VALUE",
"EGL_TRANSPARENT_GREEN_VALUE",
"EGL_TRANSPARENT_BLUE_VALUE",
"EGL_BIND_TO_TEXTURE_RGB",
"EGL_BIND_TO_TEXTURE_RGBA",
"EGL_MIN_SWAP_INTERVAL",
"EGL_MAX_SWAP_INTERVAL",
"EGL_LUMINANCE_SIZE",
"EGL_ALPHA_MASK_SIZE",
"EGL_COLOR_BUFFER_TYPE",
"EGL_RENDERABLE_TYPE",
"EGL_CONFORMANT"
};
int[] value = new int[1];
for (int i = 0; i < attributes.length; i++) {
int attribute = attributes[i];
String name = names[i];
if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
Log.w(TAG, String.format(" %s: %d\n", name, value[0]));
} else {
// Log.w(TAG, String.format(" %s: failed\n", name));
while (egl.eglGetError() != EGL10.EGL_SUCCESS);
}
}
}
// Subclasses can adjust these values:
protected int mRedSize;
protected int mGreenSize;
protected int mBlueSize;
protected int mAlphaSize;
protected int mDepthSize;
protected int mStencilSize;
private int[] mValue = new int[1];
}
private static class Renderer implements GLSurfaceView.Renderer {
public String filePath;
public void onDrawFrame(GL10 gl) {
GLESNativeLib.step();
}
public void onSurfaceChanged(GL10 gl, int width, int height) {
Log.w(TAG, "OnSufarceChanged Called");
GLESNativeLib.resize(width, height);
}
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
// Do nothing.
GLESNativeLib.init(filePath);
}
}
}
| [
"[email protected]"
] | |
f78e13d8e8fd9744562285206f985d91c34193da | 9ac8184133b176912b5489e9fe90046404cff6a3 | /e-DataStructure/1-Linear Table/e-SymbolTable/0-SymbolTable/src/iqqcode/algorithm/link/SymbolTable.java | 8fb664fe50c921a7cc10cfabe78ff2a8855724c9 | [] | no_license | IQQcode/Code-Java | d5524151b33811d423c6f877418b948f10f10c96 | 96b3157c16674be50e0b8a1ea58867a3de11d930 | refs/heads/master | 2022-12-27T12:32:05.824182 | 2022-07-31T09:32:18 | 2022-07-31T09:32:18 | 159,743,511 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,839 | java | package iqqcode.algorithm.link;
/**
* @Author: Mr.Q
* @Date: 2020-05-14 09:22
* @Description:无序符号表
* @Attention:头结点不存放数据
*/
public class SymbolTable<Key , Value> {
//记录首节点
private Node head;
//记录符号表中元素个数
private int N;
//内部节点类
private class Node {
private Key key; //键
private Value value; //值
private Node next; //下一个节点
public Node(Key key, Value value, Node next) {
this.key = key;
this.value = value;
this.next = next;
}
}
//初始化符号表
public SymbolTable() {
this.head = new Node(null , null, null);
N = 0;
}
/**
* 记录符号表中键值对的个数
* @return
*/
public int size() {
return this.N;
}
//符号表中插入键值对
public void put(Key key, Value value) {
//符号表中已经存在了键为key的键值对时：那么只需要找到该结点，将 value覆盖即可
//遍历链表，查找key是否存在
Node node = head;
while (node.next != null) { //没有到达链表尾部
node = node.next;
//判断node节点的键是否为key,如果是则替换覆盖value
if (node.key.equals(key)) {
node.value = value;
return;
}
}
//如果符号表中不存在键为key的键值：只需要创建新的结点，保存要插入的键值对
Node newNode = new Node(key, value, null);
//链表头部插入
Node tempNode = head.next;
newNode.next = tempNode;
head.next = newNode;
//元素个数+1
N++;
}
//删除符号表中键为key的键值值对
public void delete(Key key) {
//找到键为key的结点，把该结点从链表中删除
Node node = head;
while (node.next != null) {
//判断node结点的下一个结点的键是否为key(从头结点开始，但是头结点不存放数据，头结点的next节点开始遍历)
if (node.next.key.equals(key)) {
// 如果是，就删除该结点
node.next = node.next.next; //key节点指向为空
N--;
return;
}
//如果不是，继续寻找
node = node.next;
}
}
/**
* 获取键为key的Value值
* @param key
* @return
*/
public Value get(Key key) {
Node node = head;
while (node.next != null) {
node = node.next; //从存储数据的节点开始找(head.next)
if (node.key.equals(key)) {
return node.value;
}
}
return null;
}
}
| [
"[email protected]"
] | |
23434bc81e0cc2c0cfc280cbab50bcddefc7e0d9 | 4d9644e49a4be3cc16bb797936597ba7abe24004 | /core/src/main/java/com/chyee/sample/vendor/nullPaymentGateway/web/controller/NullPaymentGatewayHostedController.java | 416858f596748c23d6bac13d2fab94d0cbd412a4 | [] | no_license | qcy1121/DemoSite-master | 5895a04d7a823f012a8aa9878b1e1764da9e09e1 | adb5e2da6fa437e3c5a09f53bfe203d472df919c | refs/heads/master | 2016-09-06T17:14:24.554818 | 2014-03-22T13:35:53 | 2014-03-22T13:35:53 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,659 | java | /*
* #%L
* BroadleafCommerce Framework Web
* %%
* Copyright (C) 2009 - 2013 Broadleaf Commerce
* %%
* 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.
* #L%
*/
package com.chyee.sample.vendor.nullPaymentGateway.web.controller;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.broadleafcommerce.common.payment.dto.PaymentResponseDTO;
import org.broadleafcommerce.common.payment.service.PaymentGatewayConfiguration;
import org.broadleafcommerce.common.payment.service.PaymentGatewayWebResponseService;
import org.broadleafcommerce.common.vendor.service.exception.PaymentException;
import org.broadleafcommerce.common.web.payment.controller.PaymentGatewayAbstractController;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.chyee.sample.vendor.nullPaymentGateway.service.payment.NullPaymentGatewayConstants;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
/**
* @author Elbert Bautista (elbertbautista)
*/
@Controller("blNullPaymentGatewayHostedController")
@RequestMapping("/" + NullPaymentGatewayHostedController.GATEWAY_CONTEXT_KEY)
public class NullPaymentGatewayHostedController extends PaymentGatewayAbstractController {
protected static final Log LOG = LogFactory.getLog(NullPaymentGatewayHostedController.class);
protected static final String GATEWAY_CONTEXT_KEY = "null-checkout";
@Resource(name = "blNullPaymentGatewayHostedWebResponseService")
protected PaymentGatewayWebResponseService paymentGatewayWebResponseService;
@Resource(name = "blNullPaymentGatewayHostedConfiguration")
protected PaymentGatewayConfiguration paymentGatewayConfiguration;
@Override
public void handleProcessingException(Exception e, RedirectAttributes redirectAttributes) throws PaymentException {
if (LOG.isTraceEnabled()) {
LOG.trace("A Processing Exception Occurred for " + GATEWAY_CONTEXT_KEY +
". Adding Error to Redirect Attributes.");
}
redirectAttributes.addAttribute(PAYMENT_PROCESSING_ERROR, getProcessingErrorMessage());
}
@Override
public void handleUnsuccessfulTransaction(Model model, RedirectAttributes redirectAttributes,
PaymentResponseDTO responseDTO) throws PaymentException {
if (LOG.isTraceEnabled()) {
LOG.trace("The Transaction was unsuccessful for " + GATEWAY_CONTEXT_KEY +
". Adding Errors to Redirect Attributes.");
}
redirectAttributes.addAttribute(PAYMENT_PROCESSING_ERROR,
responseDTO.getResponseMap().get(NullPaymentGatewayConstants.RESULT_MESSAGE));
}
@Override
public String getGatewayContextKey() {
return GATEWAY_CONTEXT_KEY;
}
@Override
public PaymentGatewayWebResponseService getWebResponseService() {
return paymentGatewayWebResponseService;
}
@Override
public PaymentGatewayConfiguration getConfiguration() {
return paymentGatewayConfiguration;
}
@Override
@RequestMapping(value = "/hosted/return", method = RequestMethod.GET)
public String returnEndpoint(Model model, HttpServletRequest request, RedirectAttributes redirectAttributes,
Map<String, String> pathVars) throws PaymentException {
return super.process(model, request, redirectAttributes);
}
@Override
@RequestMapping(value = "/hosted/error", method = RequestMethod.GET)
public String errorEndpoint(Model model, HttpServletRequest request, RedirectAttributes redirectAttributes,
Map<String, String> pathVars) throws PaymentException {
redirectAttributes.addAttribute(PAYMENT_PROCESSING_ERROR,
request.getParameter(PAYMENT_PROCESSING_ERROR));
return getOrderReviewRedirect();
}
}
| [
"[email protected]"
] | |
30967bf41288433343e1266033836fa89de3ae3f | d8b74658ba26edce5b82b07431f9d9928eb5aa91 | /src/chap10/AccountTester.java | 4670364818a0c266dfd44d5ef8803436d549935c | [] | no_license | shikjfly/MingJie_Java | 7708fcb270a100648ca773cb1429f54d03d2459b | 7545607a07e5b74978fba31c6d8dc19599415305 | refs/heads/master | 2021-07-15T08:01:48.665478 | 2018-12-23T17:28:56 | 2018-12-23T17:28:56 | 142,174,874 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 298 | java | package chap10;
class AccountTester {
public static void main(String[] args) {
Account[] a = {
new Account("Zhans", "123456", 1000),
new Account("lis", "65431", 200),
new Account("liw", "654321", 200)
};
System.out.println( a[2].getId() );
}
}
| [
"[email protected]"
] | |
30f121997334cd464934a96b81b825118f8f26bc | d5dfe4d120ce5a530434084bdd378a070714497b | /src/com/dandian/pocketmoodle/activity/ShowPersonInfo.java | fbcd5b5f286b203d446af10876e09c3dc8172665 | [] | no_license | arbor1979/PocketMoodle | 5a1942ed761555e467bc263f1516b969b6777d50 | 5e7c8b0b85e6febd3e6c76a66e38198a4436ed99 | refs/heads/master | 2021-01-19T11:45:39.622109 | 2017-05-26T15:33:38 | 2017-05-26T15:33:38 | 82,262,228 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 25,145 | java | package com.dandian.pocketmoodle.activity;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.CursorLoader;
import android.content.DialogInterface;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Typeface;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.provider.Browser;
import android.provider.MediaStore;
import android.text.Html;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.method.LinkMovementMethod;
import android.text.style.StyleSpan;
import android.text.style.URLSpan;
import android.text.util.Linkify;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import com.androidquery.AQuery;
import com.androidquery.callback.ImageOptions;
import com.dandian.pocketmoodle.CampusApplication;
import com.dandian.pocketmoodle.R;
import com.dandian.pocketmoodle.api.CampusAPI;
import com.dandian.pocketmoodle.api.CampusException;
import com.dandian.pocketmoodle.api.CampusParameters;
import com.dandian.pocketmoodle.api.RequestListener;
import com.dandian.pocketmoodle.base.Constants;
import com.dandian.pocketmoodle.db.DatabaseHelper;
import com.dandian.pocketmoodle.entity.ContactsMember;
import com.dandian.pocketmoodle.entity.ImageItem;
import com.dandian.pocketmoodle.entity.User;
import com.dandian.pocketmoodle.fragment.SchoolBlogDetailFragment.MyURLSpan;
import com.dandian.pocketmoodle.util.AppUtility;
import com.dandian.pocketmoodle.util.Base64;
import com.dandian.pocketmoodle.util.DialogUtility;
import com.dandian.pocketmoodle.util.FileUtility;
import com.dandian.pocketmoodle.util.HttpMultipartPostToMoodle;
import com.dandian.pocketmoodle.util.ImageUtility;
import com.dandian.pocketmoodle.util.IntentUtility;
import com.dandian.pocketmoodle.util.MyImageGetter;
import com.dandian.pocketmoodle.util.MyTagHandler;
import com.dandian.pocketmoodle.util.PrefUtility;
import com.j256.ormlite.android.apptools.OpenHelperManager;
import com.j256.ormlite.dao.Dao;
public class ShowPersonInfo extends Activity {
public static final int REQUEST_CODE_TAKE_PICTURE = 2;// //设置图片操作的标志
public static final int REQUEST_CODE_TAKE_CAMERA = 1;// //设置拍照操作的标志
private String studentId;
private int courseId;
private String userImage;
AQuery aq;
DatabaseHelper database;
MyAdapter adapter;
Button changeheader;
private String picturePath;
private String userDomain;
private Dao<User, Integer> userDao;
private User user;
private Button btnSendMsg,btnAddLink;
private ProgressDialog loadingDlg;
JSONObject userObj;
JSONArray keyList;
private DatabaseHelper getHelper() {
if (database == null) {
database = OpenHelperManager.getHelper(this, com.dandian.pocketmoodle.db.DatabaseHelper.class);
}
return database;
}
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_person_info);
studentId = getIntent().getStringExtra("studentId");
courseId = getIntent().getIntExtra("courseId",1);
userImage = getIntent().getStringExtra("userImage");
try {
userDao = getHelper().getUserDao();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
RelativeLayout nav_bar=(RelativeLayout) findViewById(R.id.headerlayout);
int color=PrefUtility.getInt(Constants.PREF_THEME_NAVBARCOLOR, 0);
if(color!=0)
nav_bar.setBackgroundColor(color);
user=((CampusApplication)getApplicationContext()).getLoginUserObj();
userDomain=PrefUtility.get(Constants.PREF_SCHOOL_DOMAIN,"");
btnSendMsg=(Button) findViewById(R.id.btnSendMsg);
btnAddLink=(Button) findViewById(R.id.btnAddLink);
Button page_exit=(Button) findViewById(R.id.page_exit);
if(studentId.equals(user.getId()))
{
changeheader= (Button) findViewById(R.id.bt_changeHeader);
changeheader.setVisibility(View.VISIBLE);
changeheader.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
showGetPictureDiaLog();
}
});
btnSendMsg.setVisibility(View.GONE);
btnAddLink.setVisibility(View.GONE);
page_exit.setVisibility(View.VISIBLE);
}
else
{
btnSendMsg.setVisibility(View.VISIBLE);
btnAddLink.setVisibility(View.VISIBLE);
page_exit.setVisibility(View.GONE);
}
aq = new AQuery(this);
userObj=new JSONObject();
keyList=new JSONArray();
initContent();
getUserInfo();
}
private void initContent() {
ImageOptions options = new ImageOptions();
options.memCache=false;
options.fileCache=false;
options.fallback=R.drawable.ic_launcher;
options.targetWidth=200;
options.round = 100;
aq.id(R.id.iv_pic).image(userImage,options);
aq.id(R.id.tv_name).text(userObj.optString("姓名"));
if(userObj.optString("角色名称")!=null && userObj.optString("角色名称").length()>0)
{
aq.id(R.id.user_type).getTextView().setVisibility(View.VISIBLE);
aq.id(R.id.user_type).text("("+userObj.optString("角色名称")+")");
}
else
aq.id(R.id.user_type).getTextView().setVisibility(View.GONE);
if(userObj.optBoolean("是否联系人"))
{
btnAddLink.setCompoundDrawablesWithIntrinsicBounds(R.drawable.removelink, 0, 0, 0);
btnAddLink.setText(R.string.removelink);
}
else
{
btnAddLink.setCompoundDrawablesWithIntrinsicBounds(R.drawable.addlink, 0, 0, 0);
btnAddLink.setText(R.string.addlink);
}
//else
// aq.id(R.id.user_type).text(R.string.moodleuser);
aq.id(R.id.setting_tv_title).text(R.string.userinfo);
btnAddLink.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
String action;
if(userObj.optBoolean("是否联系人"))
action="removeLinkman";
else
action="addLinkman";
loadingDlg=ProgressDialog.show(ShowPersonInfo.this, null, getString(R.string.data_loading_progress),true);
loadingDlg.show();
String checkCode=PrefUtility.get(Constants.PREF_CHECK_CODE, "");
JSONObject jo = new JSONObject();
try {
jo.put("用户较验码", checkCode);
jo.put("userid", studentId);
jo.put("action", action);
jo.put("function", "getUserInfo");
} catch (JSONException e1) {
e1.printStackTrace();
}
CampusAPI.httpPostToDandian(jo, mHandler, 3);
}
});
aq.id(R.id.back).clicked(new OnClickListener(){
@Override
public void onClick(View v) {
finish();
}
});
aq.id(R.id.iv_pic).clicked(new OnClickListener(){
@Override
public void onClick(View v) {
DialogUtility.showImageDialog(ShowPersonInfo.this,userImage);
}
});
btnSendMsg.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
Intent intent = new Intent(ShowPersonInfo.this,ChatMsgActivity.class);
intent.putExtra("toid", studentId);
intent.putExtra("type", "消息");
intent.putExtra("toname", userObj.optString("姓名"));
intent.putExtra("userImage", userObj.optString("用户头像"));
startActivity(intent);
}
});
aq.id(R.id.page_exit).clicked(new OnClickListener() {
@Override
public void onClick(View v) {
AlertDialog.Builder builder = new AlertDialog.Builder(ShowPersonInfo.this);
builder.setMessage(R.string.confirmlogout)
.setCancelable(false)
.setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
((CampusApplication)getApplicationContext()).setLoginUserObj(null);
PrefUtility.put(Constants.PREF_INIT_BASEDATE_FLAG,
false);
PrefUtility
.put(Constants.PREF_INIT_CONTACT_FLAG, false);
PrefUtility.put(Constants.PREF_SELECTED_WEEK, 0);
PrefUtility.put(Constants.PREF_SITE_URL, "");
PrefUtility.put(Constants.PREF_LOGIN_NAME, "");
PrefUtility.put(Constants.PREF_LOGIN_PASS, "");
WebSiteActivity.loginDate=null;
Intent intent = new Intent(ShowPersonInfo.this,
LoginActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
System.exit(0);
dialog.dismiss();
}
})
.setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();
alert.show();
}
});
adapter=new MyAdapter(this);
aq.id(R.id.listView1).adapter(adapter);
}
public class MyAdapter extends BaseAdapter{
private LayoutInflater mInflater;
public MyAdapter(Context context){
this.mInflater = LayoutInflater.from(context);
}
@Override
public int getCount() {
// TODO Auto-generated method stub
return keyList.length();
}
@Override
public Object getItem(int arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public long getItemId(int arg0) {
// TODO Auto-generated method stub
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
if (convertView == null) {
holder=new ViewHolder();
convertView = mInflater.inflate(R.layout.list_left_right, null);
holder.title = (TextView)convertView.findViewById(R.id.left_title);
holder.info = (TextView)convertView.findViewById(R.id.right_detail);
holder.info.setAutoLinkMask(Linkify.EMAIL_ADDRESSES);
holder.private_album = (LinearLayout)convertView.findViewById(R.id.private_album);
holder.imageViews=new ImageView[4];
holder.imageViews[0]= (ImageView)convertView.findViewById(R.id.theImage);
holder.imageViews[1] = (ImageView)convertView.findViewById(R.id.imageView2);
holder.imageViews[2] = (ImageView)convertView.findViewById(R.id.imageView3);
holder.imageViews[3] = (ImageView)convertView.findViewById(R.id.imageView4);
holder.bt_changeNumber= (Button)convertView.findViewById(R.id.bt_changeNumber);
convertView.setTag(holder);
}else {
holder = (ViewHolder)convertView.getTag();
}
JSONObject keyItem=null;
try {
keyItem = keyList.getJSONObject(position);
} catch (JSONException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}
if(keyItem==null)
keyItem=new JSONObject();
String key=keyItem.optString("name");
holder.title.setText(key);
String keytype=keyItem.optString("type");
String content=userObj.optString(key);
holder.info.setText("");
if(keytype.equals("course"))
{
if(content!=null && content.length()>0)
{
JSONArray courseArray=null;
try {
courseArray=new JSONArray(content);
} catch (JSONException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//contentView.append(getString(R.string.attachment)+"：\r\n");
for(int i=0;i<courseArray.length();i++)
{
try {
JSONObject itemObj=courseArray.getJSONObject(i);
String courseName=itemObj.optString("fullname");
String detailUrl=itemObj.optString("DetailUrl");
SpannableString ss = new SpannableString(courseName);
//ss.setSpan(new StyleSpan(Typeface.NORMAL), 0, ss.length(),Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
ss.setSpan(new MyURLSpan(detailUrl), 0, ss.length(),Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
holder.info.append(ss);
if(i<courseArray.length()-1)
holder.info.append("\r\n\r\n");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
holder.info.setMovementMethod(LinkMovementMethod.getInstance());
}
}
else if(keytype.equals("description"))
{
Spanned spanned = Html.fromHtml(content, new MyImageGetter(ShowPersonInfo.this,holder.info), null);
holder.info.setText(spanned);
holder.info.setMovementMethod(LinkMovementMethod.getInstance());
}
else
holder.info.setText(content);
holder.bt_changeNumber.setVisibility(View.GONE);
holder.private_album.setVisibility(View.GONE);
return convertView;
}
public final class ViewHolder{
public TextView title;
public TextView info;
public LinearLayout private_album;
public ImageView[] imageViews;
public Button bt_changeNumber;
}
}
public class MyURLSpan extends URLSpan
{
public MyURLSpan(String url) {
super(url);
// TODO Auto-generated constructor stub
}
@Override
public void onClick(View widget) {
String mUrl=getURL();
Intent intent=new Intent(ShowPersonInfo.this,SchoolDetailActivity.class);
intent.putExtra("templateName", "博客");
intent.putExtra("interfaceName",mUrl);
intent.putExtra("title", getString(R.string.course_summary));
startActivity(intent);
}
}
private void getUserInfo() {
loadingDlg=ProgressDialog.show(this, null, getString(R.string.data_loading_progress),true);
loadingDlg.show();
String checkCode=PrefUtility.get(Constants.PREF_CHECK_CODE, "");
JSONObject jo = new JSONObject();
try {
jo.put("用户较验码", checkCode);
jo.put("userid", studentId);
jo.put("courseId", courseId);
jo.put("function", "getUserInfo");
} catch (JSONException e1) {
e1.printStackTrace();
}
CampusAPI.httpPostToDandian(jo, mHandler, 1);
}
@SuppressLint("HandlerLeak")
private Handler mHandler = new Handler() {
@SuppressLint("SimpleDateFormat")
@Override
public void handleMessage(Message msg) {
String result = "";
switch (msg.what)
{
case -1:// 请求失败
if(loadingDlg!=null)
loadingDlg.dismiss();
AppUtility.showErrorToast(ShowPersonInfo.this,
msg.obj.toString());
break;
case 1:
if(loadingDlg!=null)
loadingDlg.dismiss();
result = msg.obj.toString();
try {
JSONObject jo = new JSONObject(result);
if (jo.optString("结果").equals("失败"))
AppUtility.showErrorToast(ShowPersonInfo.this, jo.optString("error"));
else
{
userObj=jo.getJSONObject("个人资料");
userImage=userObj.optString("用户头像");
keyList=jo.getJSONArray("显示字段");
initContent();
}
} catch (JSONException e) {
e.printStackTrace();
}
break;
case 2:
result = msg.obj.toString();
try {
JSONObject jo = new JSONObject(result);
if (jo.optString("结果").equals("失败"))
AppUtility.showErrorToast(ShowPersonInfo.this, jo.optString("error"));
else
{
AppUtility.showToastMsg(ShowPersonInfo.this, getString(R.string.uploadSuccess));
userImage=jo.getString("newpicurl");
user.setUserImage(userImage);
try {
userDao.update(user);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
initContent();
}
}
catch (JSONException e) {
e.printStackTrace();
}
break;
case 3:
if(loadingDlg!=null)
loadingDlg.dismiss();
result = msg.obj.toString();
try {
JSONObject jo = new JSONObject(result);
if (jo.optString("结果").equals("失败"))
AppUtility.showErrorToast(ShowPersonInfo.this, jo.optString("error"));
else
{
userObj.put("是否联系人",jo.optBoolean("是否联系人"));
initContent();
}
}
catch (JSONException e) {
e.printStackTrace();
}
break;
case 5:
Bundle upLoadbundle = (Bundle) msg.obj;
result = upLoadbundle.getString("result");
try {
JSONArray ja = new JSONArray(result);
JSONObject jo=ja.getJSONObject(0);
if(jo!=null && jo.optString("itemid").length()>0)
{
//userImage=userDomain+"/pluginfile.php/"+jo.optString("contextid")+"/user/icon/clean/"+URLEncoder.encode(jo.optString("filename"),"UTF-8");
updateServerUserInfo(jo);
}else{
DialogUtility.showMsg(ShowPersonInfo.this, getString(R.string.failed)+jo.optString("error"));
}
}catch (Exception e) {
AppUtility.showToastMsg(ShowPersonInfo.this, e.getMessage());
e.printStackTrace();
}
break;
}
}
};
private void showGetPictureDiaLog() {
View view = getLayoutInflater()
.inflate(R.layout.view_get_picture, null);
Button cancel = (Button) view.findViewById(R.id.cancel);
TextView byCamera = (TextView) view.findViewById(R.id.tv_by_camera);
TextView byLocation = (TextView) view.findViewById(R.id.tv_by_location);
final AlertDialog ad = new AlertDialog.Builder(this).setView(view)
.create();
Window window = ad.getWindow();
window.setGravity(Gravity.BOTTOM);// 在底部弹出
window.setWindowAnimations(R.style.CustomDialog);
ad.show();
cancel.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
ad.dismiss();
}
});
byCamera.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
getPictureByCamera();
ad.dismiss();
}
});
byLocation.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
getPictureFromLocation();
ad.dismiss();
}
});
}
private synchronized void getPictureByCamera() {
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);// 调用android自带的照相机
String sdStatus = Environment.getExternalStorageState();
if (!sdStatus.equals(Environment.MEDIA_MOUNTED)) { // 检测sd是否可用
AppUtility.showToastMsg(this, getString(R.string.Commons_SDCardErrorTitle));
return;
}
picturePath = FileUtility.getRandomSDFileName("jpg");
File mCurrentPhotoFile = new File(picturePath);
Uri uri = Uri.fromFile(mCurrentPhotoFile);
intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
startActivityForResult(intent, REQUEST_CODE_TAKE_CAMERA);
}
public void getPictureFromLocation() {
String status = Environment.getExternalStorageState();
if (status.equals(Environment.MEDIA_MOUNTED)) {// 判断是否有SD卡
/*
Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(intent, REQUEST_CODE_TAKE_PICTURE);
*/
Intent intent;
intent = new Intent(Intent.ACTION_PICK,
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(intent, REQUEST_CODE_TAKE_PICTURE);
} else {
AppUtility.showToastMsg(this, getString(R.string.Commons_SDCardErrorTitle));
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case REQUEST_CODE_TAKE_CAMERA: // 拍照返回
if (resultCode == RESULT_OK) {
if(picturePath!=null)
rotateAndCutImage(new File(picturePath));
else
AppUtility.showToastMsg(this, getString(R.string.getcamerafailed));
}
break;
case REQUEST_CODE_TAKE_PICTURE:
if (data != null) {
//picturePath = data.getStringExtra("filepath");
//String myImageUrl = data.getDataString();
//Uri uri = Uri.parse(myImageUrl);
Uri uri = data.getData();
String[] pojo = { MediaStore.Images.Media.DATA };
CursorLoader cursorLoader = new CursorLoader(this, uri, pojo, null,null, null);
Cursor cursor = cursorLoader.loadInBackground();
if(cursor!=null)
{
cursor.moveToFirst();
picturePath = cursor.getString(cursor.getColumnIndex(pojo[0]));
String tempPath =FileUtility.getRandomSDFileName("jpg");
if(FileUtility.copyFile(picturePath,tempPath))
rotateAndCutImage(new File(tempPath));
else
AppUtility.showErrorToast(this,getString(R.string.failedcopytosdcard));
}
else
AppUtility.showErrorToast(this, getString(R.string.getcamerafailed));
}
break;
case 3:
if (resultCode == 200 && data != null) {
String picPath = data.getStringExtra("picPath");
SubmitUploadFile(picPath);
}
default:
break;
}
}
private void rotateAndCutImage(final File file) {
if(!file.exists()) return;
if(AppUtility.formetFileSize(file.length()) > 5242880*2){
AppUtility.showToastMsg(this, String.format(getString(R.string.maxfilesize),10));
}else{
ImageUtility.rotatingImageIfNeed(file.getAbsolutePath());
Intent intent=new Intent(this,CutImageActivity.class);
intent.putExtra("picPath", file.getAbsolutePath());
startActivityForResult(intent,3);
}
}
public void SubmitUploadFile(String picPath){
CampusParameters params = new CampusParameters();
final String localfile = picPath;
String token=PrefUtility.get(Constants.PREF_CHECK_TOKEN,"");
params.add("token",token);
params.add("filearea","draft");
params.add("pic", picPath);
String url=userDomain+"/webservice/upload.php";
HttpMultipartPostToMoodle post = new HttpMultipartPostToMoodle(this, url, params){
@Override
protected void onPostExecute(String result) {
Bundle bundle = new Bundle();
bundle.putString("result", result);
bundle.putString("localfile", localfile);
Message msg = new Message();
msg.what = 5;
msg.obj = bundle;
mHandler.sendMessage(msg);
this.pd.dismiss();
}
};
post.execute();
}
private void updateServerUserInfo(JSONObject jo)
{
String checkCode=PrefUtility.get(Constants.PREF_CHECK_CODE, "");
try {
jo.put("用户较验码", checkCode);
jo.put("action", "changeAvatar");
jo.put("function", "getUserInfo");
} catch (JSONException e1) {
e1.printStackTrace();
}
CampusAPI.httpPostToDandian(jo, mHandler, 2);
}
@Override
public void onSaveInstanceState(Bundle savedInstanceState){
super.onSaveInstanceState(savedInstanceState);
savedInstanceState.putString("picturePath", picturePath);
savedInstanceState.putString("studentId", studentId);
savedInstanceState.putString("userImage", userImage);
}
@Override
public void onRestoreInstanceState(Bundle savedInstanceState){
super.onRestoreInstanceState(savedInstanceState);
picturePath = savedInstanceState.getString("picturePath");
studentId = savedInstanceState.getString("studentId");
userImage = savedInstanceState.getString("userImage");
}
}
| [
"[email protected]"
] | |
0f69ae80e57a90503b9a1756aef01719fe73c824 | 1c3190e50352b61dcb0453037431c832442d7a86 | /app/src/main/java/com/example/exercisepam/ClassNama.java | 51cc5a09d89bb450549646e66b8e25251c53263d | [] | no_license | imamzakky/Exercise_1_PAM | 5c394c19a009f8d3819ae266473fefa5a5d3bd9e | be160ddee6d0ec8610d8121df126e493d9b17f65 | refs/heads/master | 2023-04-02T13:52:42.583026 | 2021-04-07T01:56:03 | 2021-04-07T01:56:03 | 355,381,863 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 227 | java | package com.example.exercisepam;
public class ClassNama {
private String Nama;
public ClassNama(String nama)
{
this.Nama = nama;
}
public String getName()
{
return this.Nama;
}
}
| [
"[email protected]"
] | |
1dee155f35744845030135038f092970e56fe44d | 78a3241adadea6fb1094c8413947ec3e6f3d93ba | /xmlProject/src/by/http/xml/parser/dom/CatalogDataDOM.java | f8bb82257fecc6d27f4260bfeec983afbd730bd8 | [] | no_license | KaledinaDarya/JDK1 | 6487a4b05ba3a9fcd10d800b8ce90a3ca4e7e7b9 | 1717d113bbf9af68a3370d0c83492cd16b79c982 | refs/heads/master | 2020-05-18T23:05:03.601409 | 2019-05-03T06:03:03 | 2019-05-03T06:03:03 | 184,704,495 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,279 | java | package by.http.xml.parser.dom;
import java.awt.geom.CubicCurve2D;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class CatalogDataDOM {
private static final String XML_FILE_PATH = "resources/family.xml";
public static void main(String[] args) {
CatalogDataDOM catalogDataDOM = new CatalogDataDOM();
catalogDataDOM.readStationEquip();
}
public void readStationEquip() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(XML_FILE_PATH);
parseDocumentSecond(document);
} catch (ParserConfigurationException | SAXException | IOException e) {
e.printStackTrace();
}
}
/*private void parseDocument(Document document) {
Element root = document.getDocumentElement();
System.out.println(root.getNodeName());
NodeList elements = root.getChildNodes();
for (int i = 0; i < elements.getLength(); i++) {
elements.item(i).getNodeName();
System.out.println("name(i): " + elements.item(i).getNodeName());
if (elements.item(i).getNodeType() == 1) {
Element current = (Element)elements.item(i);
NodeList childrenElements = current.getChildNodes();
for (int j = 0; j < childrenElements.getLength(); j++) {
childrenElements.item(j).getNodeName();
if (childrenElements.item(j).getNodeType() == 1) {
System.out.println("--- name(j): " + childrenElements.item(j).getNodeName());
}
}
}
}
}*/
private static void parseDocumentSecond(Document document) {
Element root = document.getDocumentElement();
NodeList node = root.getElementsByTagName("family");
for (int i = 0; i < node.getLength(); i++) {
Element currentNode = (Element)node.item(i);
String name = currentNode.getNodeName();
System.out.println(name);
String adress = currentNode.getAttribute("adress");
System.out.println(adress);
System.out.println(node.item(i).getChildNodes());
NodeList entity = currentNode.getChildNodes();
for (int j = 0; j < entity.getLength(); j++) {
if (entity.item(j).getNodeType() == 1) {
String entityName = entity.item(j).getNodeName();
System.out.println(entityName);
}
}
Element mother = getSingleChild(currentNode, "mother");
System.out.println(mother.getNodeName() + ":");
getAllChildFieldsWithData(mother);
}
}
private static Element getSingleChild(Element element, String childName) {
NodeList nlist = element.getElementsByTagName(childName);
Element child = (Element) nlist.item(0);
return child;
}
private static void getAllChildFieldsWithData(Element element) {
NodeList fields = element.getChildNodes();
for (int i = 0; i < fields.getLength(); i++) {
if (fields.item(i).getNodeType() == 1) {
String field = fields.item(i).getNodeName();
System.out.print("--- " + field);
String text = fields.item(i).getTextContent().trim();
System.out.println(" - " + text);
}
}
}
}
| [
"[email protected]"
] | |
92ccc34fcbf24c453770b1a501ae07c7924810ad | 83677ff5d7676f9bd57a178adcc41b3638cf0e1a | /YGOCard/src/com/yugioh/android/define/PathDefine.java | 5f400c12b65203b8cb252ffe9914a2cd56886bfb | [] | no_license | yucc136/root-tools | 3a190af4e50c663edf15f0c0cbf07fb734d11936 | 3c3ee6e4df2ec03b70325cd3d04e9f995959d1e5 | refs/heads/master | 2021-01-18T05:40:45.916514 | 2013-04-24T15:52:40 | 2013-04-24T15:52:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 332 | java | package com.yugioh.android.define;
public class PathDefine {
public static final String ROOT_PATH = "/sdcard/.yugioh/";
public static final String DATABASE_PATH = ROOT_PATH + "yugioh.db";
public static final String PICTURE_PATH = ROOT_PATH + "images/";
public static final String DOWNLOAD_PATH = ROOT_PATH + "downloads/";
}
| [
"[email protected]"
] | |
62dd99a742db6176c9780c18408d2b9a35ebf1a3 | af10e4a8e560a805579b9cbf597e95072c1dc38c | /kork-web/src/main/java/com/netflix/spinnaker/kork/web/exceptions/BaseExceptionHandlers.java | ba033df27a42a0b003c503523706f9c70fcaf1e8 | [
"Apache-2.0"
] | permissive | spinnaker/kork | 72d4df1c40c326924bb167880b5abf3c40a9516b | c63ea930b6c8bef9dc2122fea156533d16902837 | refs/heads/master | 2023-08-31T19:34:54.330351 | 2023-08-25T23:57:11 | 2023-08-25T23:57:11 | 19,836,152 | 42 | 190 | Apache-2.0 | 2023-09-08T07:56:10 | 2014-05-15T21:37:21 | Java | UTF-8 | Java | false | false | 1,629 | java | /*
* Copyright 2021 Salesforce, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.spinnaker.kork.web.exceptions;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
public class BaseExceptionHandlers extends ResponseEntityExceptionHandler {
private final DefaultErrorAttributes defaultErrorAttributes = new DefaultErrorAttributes();
protected final ExceptionMessageDecorator exceptionMessageDecorator;
public BaseExceptionHandlers(ExceptionMessageDecorator exceptionMessageDecorator) {
this.exceptionMessageDecorator = exceptionMessageDecorator;
}
protected void storeException(
HttpServletRequest request, HttpServletResponse response, Exception ex) {
// store exception as an attribute of HttpServletRequest such that it can be referenced by
// GenericErrorController
defaultErrorAttributes.resolveException(request, response, null, ex);
}
}
| [
"[email protected]"
] | |
5efbc277d77d9de2f3dc82072f1f2768e7e9bc75 | b09d1c4bd89866551116cc26716904048d026f71 | /test/main/java/common/util/jasper/practice1/JasperPractice1.java | 262838a7026d19ef4b0f7a1c586cf5743a8e1cae | [] | no_license | santoshmondal/dbstore | 6a1419352bfa9cc15ab67455fa00645aae49808c | cc3ea14423f1a9b165e1f9525127cd576b70c82c | refs/heads/master | 2020-12-24T18:03:50.649284 | 2015-05-06T09:43:45 | 2015-05-06T09:43:45 | 33,531,641 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,730 | java | package common.util.jasper.practice1;
import java.util.HashMap;
import java.util.Map;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
public class JasperPractice1 {
public static void main(String[] args) {
exportToPdf();
}
public static void exportToPdf() {
System.out.println("Start with Report Design ...");
try {
// Compile it generates .jasper
String sourceFileName = JasperPractice1.class.getClassLoader().getResource("DataSourceReport.jrxml").getFile();
JasperCompileManager.compileReportToFile(sourceFileName);
String sourceJasperFileName = JasperPractice1.class.getClassLoader().getResource("DataSourceReport.jasper").getFile();
Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("ReportTitle", "Address Report");
parameters.put("DataFile", "CustomDataSource.java");
// fillreport it generates .jrprint
JRBeanCollectionDataSource collectionDS = new JRBeanCollectionDataSource(CustomBeanFactory.getBeanCollection());
JasperFillManager.fillReportToFile(sourceJasperFileName, parameters, collectionDS);
// export
String jrprintName = JasperPractice1.class.getClassLoader().getResource("DataSourceReport.jrprint").getFile();
JasperExportManager.exportReportToPdfFile(jrprintName, "reports/datasource.pdf");
} catch (JRException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Done reporting!!!");
}
}
| [
"[email protected]@d7ca004c-2e9b-46a1-1ef3-e92f5e9fb6a3"
] | [email protected]@d7ca004c-2e9b-46a1-1ef3-e92f5e9fb6a3 |
843c4a2466cdd54a3a4dfed6b9a686ea84b4b78a | 4e71cca88cf2d9970cae31db398d06c775f8f227 | /app/src/main/java/com/example/a2mg/ui/home/HomeFragment.java | 6d95c5ce20fd0e3f1693719debee9c4e04857d79 | [] | no_license | ClarissaBaciu/2MG-SheHacks | 9f5f91cbfff756b324a4559494be8554b3f4c5e1 | 46ea9495a5bfd112ea85145b49178cf3a5c9f7ac | refs/heads/main | 2023-04-06T15:21:24.729504 | 2023-03-14T23:47:50 | 2023-03-14T23:47:50 | 328,336,993 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,141 | java | package com.example.a2mg.ui.home;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;
import com.example.a2mg.R;
public class HomeFragment extends Fragment {
private HomeViewModel homeViewModel;
public View onCreateView(@NonNull LayoutInflater inflater,
ViewGroup container, Bundle savedInstanceState) {
homeViewModel =
new ViewModelProvider(this).get(HomeViewModel.class);
View root = inflater.inflate(R.layout.fragment_home, container, false);
final TextView textView = root.findViewById(R.id.text_home);
homeViewModel.getText().observe(getViewLifecycleOwner(), new Observer<String>() {
@Override
public void onChanged(@Nullable String s) {
textView.setText(s);
}
});
return root;
}
} | [
"[email protected]"
] | |
bab9dacafc36488f04e972e80ad8465135f92169 | 70f3242389afdb74f60cdac345240c197fce5d69 | /src/com/starterkit/view/handlers/DeleteDoneView.java | 41dd00aacc8c8778f067fbf5c9119184ae3bfffa | [] | no_license | mkordulska/rcp | abd4fd525fe7033130052d072e4fea37be1f8116 | 6a0e5e500b9b39b7cba212b6fc4bc083159281ba | refs/heads/master | 2021-03-19T07:11:01.193813 | 2015-09-04T06:21:33 | 2015-09-04T06:21:33 | 42,036,631 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 946 | java | package com.starterkit.view.handlers;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.core.commands.IHandlerListener;
public class DeleteDoneView implements IHandler {
@Override
public void addHandlerListener(IHandlerListener handlerListener) {
// TODO Auto-generated method stub
}
@Override
public void dispose() {
// TODO Auto-generated method stub
}
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean isEnabled() {
// TODO Auto-generated method stub
return true;
}
@Override
public boolean isHandled() {
// TODO Auto-generated method stub
return true;
}
@Override
public void removeHandlerListener(IHandlerListener handlerListener) {
// TODO Auto-generated method stub
}
}
| [
"[email protected]"
] | |
f5b9fef845088296ec7bad26fa180362cdb708ae | 960f0bcccb7d58f4a6b9f9fcb661287c47f18102 | /src/main/java/edu/ifal/calendario/DemoApplication.java | 7ab9954bd5bcceed31a9709672a7c0707a4ddc79 | [] | no_license | josyoliveira/calendario | 6c2a640e7ae864f7c6eac69fb4a10022e101e351 | 015b3ef306affa55e4055544cdbec1a413bbdea6 | refs/heads/master | 2020-12-05T16:19:38.859631 | 2020-01-13T19:18:32 | 2020-01-13T19:18:32 | 232,171,625 | 0 | 0 | null | 2020-10-13T18:40:02 | 2020-01-06T19:37:35 | Java | UTF-8 | Java | false | false | 308 | java | package edu.ifal.calendario;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
| [
"[email protected]"
] | |
6626710dc5b0bcd6a1ccd60cfa609d2057a668bc | d8110d9a2f7c90bd0b65a327f7a081cf874121de | /src/gt000/LT0077.java | aeb44529cef09a88cc48e348b1cd77fb8ffb5975 | [] | no_license | checkoutb/leetcodejava | 31892c2200a29662cd74aa13711a77f5da70bcf7 | 5e140fa845f2c4a0199d01fc1a8e427ed1362aff | refs/heads/master | 2021-07-22T06:31:21.954239 | 2018-12-08T11:54:42 | 2018-12-08T11:54:42 | 112,287,037 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,245 | java | package gt000;
import java.util.LinkedList;
import java.util.List;
import utils.LTUtils;
/**
* 77. Combinations
* */
public class LT0077 {
public static void main(String[] args) {
int n = 4;
int k = 2;
LTUtils.showListOfList(Lt0077a(n, k));
}
public static List<List<Integer>> Lt0077b(int n, int k)
{
List<List<Integer>> result = new LinkedList<>();
List<Integer> list = null;
int i = 0;
int j = 0;
int m = 0;
int t1 = 0;
int t2 = 0;
int[] nArr = new int[n];
for(i = 0; i < n; i++)
{
nArr[i] = i + 1;
}
// m = k;
// for(i = 0; i < n; i++)
// {
// while(m > 0)
// {
// for(j = i; j < n; j++)
// {
//
// }
// }
// }
// m = k;
// while(m > 0)
// {
// for(i = 0; i < n; i++)
// {
//
// }
// }
// m = k;
// int len = n - k;
// for(i = 0; i < len; i++)
// {
// list = new LinkedList<>();
// list.add(i);
// m--;
// while(m > 0)
// {
// for(j = i + 1; j < n; j++)
// {
// list.add(j);
// }
// }
// }
return result;
}
// 看来想要快，还是得直接得出组合，不能for 1-n。。
public static List<List<Integer>> Lt0077a(int n, int k)
{
List<List<Integer>> result = new LinkedList<>();
List<Integer> list = null;
int i = 0;
int j = 0;
int t1 = 0;
int t2 = 0;
int nBit = 1 << n;
int[] nArr = new int[n];
for(i = 0; i < n; i++)
{
nArr[i] = i + 1;
}
// 不知道怎么样才能快速判断 一个int，由几个1组成。。。看来>>1是最快的了。
for(i = 0; i < nBit; i++)
{
}
// Integer a = 111;
// System.out.println(a.byteValue());
// System.out.println(a.BYTES);
// System.out.println(a.byteValue());
// System.out.println(a.toBinaryString(111).toCharArray());
// System.out.println();
// Byte as = 0x11;
// System.out.println(as.intValue());
// System.out.println(as.byteValue());
// System.out.println(as.BYTES);
// System.out.println(as.toString());
// System.out.println();
// // 应该是第二种方法快，快至少1倍，
// for(i = 0; i < 100000; i++)
// {
//
// }
//
// char[] ch;
// int count = 0;
//
// Long start = System.nanoTime();
//
// for(i = 0; i < 100000; i++)
// {
// count = 0;
// ch = Integer.toBinaryString(i).toCharArray();
// for(char ch1 : ch)
// {
// if(ch1 == '1')
// {
// count++;
// }
// }
// }
//
// System.out.println(System.nanoTime() - start);
//
//
// start = System.nanoTime();
//
// for(i = 0; i < 100000; i++)
// {
// count = 0;
// t1 = i;
// while(t1 > 0)
// {
// if(t1 % 2 == 1)
// {
// count++;
// }
// t1 = t1 >> 1;
// }
// }
//
// System.out.println(System.nanoTime() - start);
return result;
}
// 昨天正好看过一个排列组合的代码，不过那个是全排列，全组合，没有元素个数的限制。 http://blog.csdn.net/joson793847469/article/details/52743632
// 有上面的借鉴，但是还是差点翻车。。本地改了好久才让它输出对。。
// 64ms...那么多的3ms怎么来的。。
public static List<List<Integer>> Lt0077(int n, int k)
{
List<List<Integer>> result = new LinkedList<>();
List<Integer> list = null;
int nBit = 1 << n;
int i = 0;
int t = 0;
int t2 = 0;
int count = 0;
for(i = 0; i < nBit; i++)
{
count = 0;
t = i;
while(t > 0)
{
if(t % 2 == 1)
{
count++;
}
t = t >> 1;
}
if(count == k)
{
t = i;
t2 = 1;
list = new LinkedList<>();
while(t > 0)
{
if(t % 2 == 1)
{
list.add(t2);
}
t2++;
t = t >> 1;
}
result.add(list);
}
}
return result;
}
}
| [
"[email protected]"
] | |
743eb65374b264634be73c7d22463160f947617e | b87346381f687b74b48bf0192af67f28cf3e1b1b | /src/notation/Notation.java | 3b0d790fe2f1b1f00fc3460861a1fe3a663be677 | [] | no_license | kamild706/Calculator | c3e4a3e9fbff291cc733dedd44de0a35f7de9efe | 63a873aa03198a3a4c2d414ccd6705715c52480c | refs/heads/master | 2020-03-28T20:00:42.410776 | 2018-09-21T19:50:09 | 2018-09-21T19:50:09 | 149,030,010 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 262 | java | package notation;
import parser.BinaryOperation;
import parser.Constant;
import parser.UnaryOperation;
public interface Notation {
String parse(BinaryOperation operation);
String parse(UnaryOperation operation);
String parse(Constant constant);
}
| [
"[email protected]"
] | |
ade9e95bd13fb43f73926cfb32ac481524856b6b | e3111c5e48586aa560064e58de4f5c0410f52717 | /src/conexp/core/layout/layeredlayout/AllConceptOnOneLayerHaveDifferentXCoordinatesEvaluationFunction.java | 5712164e29d43076f58733aa75cc3ca5f06923b0 | [] | no_license | keinstein/Conexp | 0512cddf8955f7958b79de8631cd233ea300478e | 4079aadc0a62d70d2d1028a186c5cedf1de618c3 | refs/heads/master | 2020-03-29T13:48:42.641962 | 2018-09-23T13:00:28 | 2018-09-23T13:00:28 | 149,983,449 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,867 | java | /**
* Copyright (c) 2000-2006, Serhiy Yevtushenko
* All rights reserved.
* Please read license.txt for licensing issues.
**/
package conexp.core.layout.layeredlayout;
import conexp.core.LatticeElement;
import conexp.core.layout.ConceptCoordinateMapper;
import util.collection.CollectionFactory;
import util.gui.GraphicObjectsFactory;
import java.awt.geom.Point2D;
import java.util.SortedSet;
public class AllConceptOnOneLayerHaveDifferentXCoordinatesEvaluationFunction implements IEvaluationFunction {
private LatticeElement[][] elementsByLayers;
ConceptCoordinateMapper conceptCoordinateMapper;
public AllConceptOnOneLayerHaveDifferentXCoordinatesEvaluationFunction(ConceptCoordinateMapper mapper, LatticeElement[][] elementsByLayers) {
this.elementsByLayers = elementsByLayers;
setConceptCoordinateMapper(mapper);
}
public void setConceptCoordinateMapper(ConceptCoordinateMapper conceptCoordinateMapper) {
this.conceptCoordinateMapper = conceptCoordinateMapper;
}
public double getEvaluationForLattice() {
int violatedConstraints = 0;
Point2D coords = GraphicObjectsFactory.makePoint2D();
for (int layer = 0; layer < elementsByLayers.length; layer++) {
LatticeElement[] layerInfo = elementsByLayers[layer];
SortedSet coordinatesOfElementsInLayer = CollectionFactory.createSortedSet();
for (int elementOfLayer = 0; elementOfLayer < layerInfo.length; elementOfLayer++) {
conceptCoordinateMapper.setCoordsForConcept(layerInfo[elementOfLayer], coords);
Double xcoord = new Double(coords.getX());
coordinatesOfElementsInLayer.add(xcoord);
}
violatedConstraints += layerInfo.length - coordinatesOfElementsInLayer.size();
}
return -violatedConstraints;
}
}
| [
""
] | |
5865b1b799e2e0519bb98ec4b4c9ac3fb332951e | b133ba78ea985b11320e6e5dcdebd0c092de978f | /Samsung.java | 27c23187c6063093491b866f5de3029f93c77c2e | [
"MIT"
] | permissive | mvnsia/OOADP-Assignment | 2481852fe5203d62ac678bb72f129de5d5b625d7 | 8d1592441f598dbcd130fcccd026911d1d33f721 | refs/heads/master | 2022-04-25T16:12:03.499303 | 2020-04-28T06:59:30 | 2020-04-28T06:59:30 | 259,555,971 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 237 | java |
public class Samsung implements MobileShop {
@Override
public void modelNo() {
System.out.println(" Samsung galaxy tab 3 ");
}
@Override
public void price() {
System.out.println(" Rs 45000.00 ");
}
}
| [
"[email protected]"
] | |
75a95b5eab4dc89c53a8d7509f77436491ba50bf | 6a0dec28e7d606075c86c3f43b527cd04112347b | /android/java/src/com/jooyuu/qrlogin4game/zxing/decoding/CaptureActivityHandler.java | 025bb0ec938698f158e8c64cd61fafcd32c01263 | [] | no_license | atom-chen/myCode | 8b8af86f2c98255174b26fba3c819aba973f33e7 | ebecd0af139ffb4caf0d3c7f603b27c461f0839f | refs/heads/master | 2020-12-04T13:31:54.251342 | 2017-02-28T02:20:43 | 2017-02-28T02:20:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,168 | java | /*
* Copyright (C) 2008 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.jooyuu.qrlogin4game.zxing.decoding;
import java.util.Vector;
import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.Result;
import com.jooyuu.qrlogin4game.zxing.CaptureActivity;
import com.jooyuu.qrlogin4game.zxing.MessageIDs;
import com.jooyuu.qrlogin4game.zxing.view.ViewfinderResultPointCallback;
/**
* This class handles all the messaging which comprises the state machine for capture.
*
* @author [email protected] (Daniel Switkin)
*/
public final class CaptureActivityHandler extends Handler {
private static final String TAG = CaptureActivityHandler.class.getSimpleName();
private final CaptureActivity activity;
private final DecodeThread decodeThread;
private State state;
private enum State {
PREVIEW,
SUCCESS,
DONE
}
public CaptureActivityHandler(CaptureActivity activity, Vector<BarcodeFormat> decodeFormats,
String characterSet) {
this.activity = activity;
decodeThread = new DecodeThread(activity, decodeFormats, characterSet,
new ViewfinderResultPointCallback(activity.getViewfinderView()));
decodeThread.start();
state = State.SUCCESS;
// Start ourselves capturing previews and decoding.
//CameraManager.get().startPreview();
activity.getCameraManager().startPreview();
restartPreviewAndDecode();
}
@Override
public void handleMessage(Message message) {
switch (message.what) {
case MessageIDs.auto_focus:
//Log.d(TAG, "Got auto-focus message");
// When one auto focus pass finishes, start another. This is the closest thing to
// continuous AF. It does seem to hunt a bit, but I'm not sure what else to do.
if (state == State.PREVIEW) {
// CameraManager.get().requestAutoFocus(this, MessageIDs.auto_focus);
activity.getCameraManager().requestAutoFocus(this, MessageIDs.auto_focus);
}
break;
case MessageIDs.restart_preview:
Log.d(TAG, "Got restart preview message");
restartPreviewAndDecode();
break;
case MessageIDs.decode_succeeded:
Log.d(TAG, "Got decode succeeded message");
state = State.SUCCESS;
Bundle bundle = message.getData();
Bitmap barcode = bundle == null ? null :
(Bitmap) bundle.getParcelable(DecodeThread.BARCODE_BITMAP);
activity.handleDecode((Result) message.obj, barcode);
break;
case MessageIDs.decode_failed:
// We're decoding as fast as possible, so when one decode fails, start another.
state = State.PREVIEW;
//CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), MessageIDs.decode);
activity.getCameraManager().requestPreviewFrame(decodeThread.getHandler(), MessageIDs.decode);
break;
case MessageIDs.return_scan_result:
Log.d(TAG, "Got return scan result message");
activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
activity.finish();
break;
case MessageIDs.launch_product_query:
Log.d(TAG, "Got product query message");
String url = (String) message.obj;
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
activity.startActivity(intent);
break;
}
}
public void quitSynchronously() {
state = State.DONE;
//CameraManager.get().stopPreview();
activity.getCameraManager().stopPreview();
Message quit = Message.obtain(decodeThread.getHandler(), MessageIDs.quit);
quit.sendToTarget();
try {
decodeThread.join();
} catch (InterruptedException e) {
// continue
}
// Be absolutely sure we don't send any queued up messages
removeMessages(MessageIDs.decode_succeeded);
removeMessages(MessageIDs.decode_failed);
}
private void restartPreviewAndDecode() {
if (state == State.SUCCESS) {
state = State.PREVIEW;
// CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), MessageIDs.decode);
activity.getCameraManager().requestPreviewFrame(decodeThread.getHandler(), MessageIDs.decode);
// CameraManager.get().requestAutoFocus(this, MessageIDs.auto_focus);
activity.getCameraManager().requestAutoFocus(this, MessageIDs.auto_focus);
activity.drawViewfinder();
}
}
}
| [
"[email protected]"
] | |
bb562ed81195f51b9a79e119ba1dc51e3d3c41fb | 86fbdf811172b3f892033b52345bd25d898c3cff | /src/main/java/com/oilgascs/security/jwt/JWTFilter.java | 137f295d1bdd434f6e2587de7ce324353998413e | [] | no_license | udaysalian/gps_feb_2019 | 031d9ed63123cde4a7fb3a19273c66f76257e863 | 0b257817515a2d4352fcc2831caa36332168c18b | refs/heads/master | 2021-07-02T14:56:35.800000 | 2019-02-18T00:34:37 | 2019-02-18T00:34:37 | 171,182,732 | 0 | 1 | null | 2020-09-18T13:53:29 | 2019-02-17T23:04:54 | Java | UTF-8 | Java | false | false | 1,838 | java | package com.oilgascs.security.jwt;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.GenericFilterBean;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
* Filters incoming requests and installs a Spring Security principal if a header corresponding to a valid user is
* found.
*/
public class JWTFilter extends GenericFilterBean {
public static final String AUTHORIZATION_HEADER = "Authorization";
private TokenProvider tokenProvider;
public JWTFilter(TokenProvider tokenProvider) {
this.tokenProvider = tokenProvider;
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
String jwt = resolveToken(httpServletRequest);
if (StringUtils.hasText(jwt) && this.tokenProvider.validateToken(jwt)) {
Authentication authentication = this.tokenProvider.getAuthentication(jwt);
SecurityContextHolder.getContext().setAuthentication(authentication);
}
filterChain.doFilter(servletRequest, servletResponse);
}
private String resolveToken(HttpServletRequest request){
String bearerToken = request.getHeader(AUTHORIZATION_HEADER);
if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
return bearerToken.substring(7);
}
return null;
}
}
| [
"021266ffs01k"
] | 021266ffs01k |
33ebff687e424fa36cc089c7928feaf0371f186a | 2605e64c60f0c7428daec6586079fcfc9c6f4f7a | /TeamZeroServer/src/serverTests/AllTests.java | 4c62a83ad07dab009b7ad318fa77e7d8de300e04 | [] | no_license | Lotunnnnny/team_zero_application | f3c59a061185676bf10132c5828f241cb3cfc109 | 018c4dc4cae6685e84768238058fe025c78846eb | refs/heads/master | 2021-05-21T22:20:19.744281 | 2020-04-03T20:51:12 | 2020-04-03T20:51:12 | 213,191,929 | 1 | 0 | null | 2019-10-06T15:21:01 | 2019-10-06T15:21:01 | null | UTF-8 | Java | false | false | 200 | java | package serverTests;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({})
public class AllTests {
}
| [
"[email protected]"
] | |
76cfe795ccfb7b694b0032d2449edf5c8f9b885b | 33fefaf362ac1bddbbfe12214d9ea9773d98ccf6 | /src/main/java/de/oglimmer/game/logic/unit/SwordmanUnit.java | 0b298c6a847129c5d11349fbaafa0a63d2ead516 | [
"MIT"
] | permissive | oglimmer/yatdg | 0f80ebb305546ed3546c44114eedcf1eac34baed | 0cce1d9071abe98058358b1cdb7f9c21de463fd3 | refs/heads/master | 2023-05-29T09:53:53.193504 | 2023-05-13T20:11:50 | 2023-05-13T20:12:02 | 4,104,651 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 335 | java | package de.oglimmer.game.logic.unit;
import de.oglimmer.game.logic.Player;
public class SwordmanUnit extends Unit {
public SwordmanUnit(Player owningPlayer, int y) {
super(owningPlayer, "Swordman", y, 10, 40,
"Inflicts severe damage to enemy units at the same location."
+ " Must be deployed to the main road.");
}
}
| [
"[email protected]"
] | |
8979216d4a07dc1ed0c5f138262781175352a0bd | 81a3d1ba9538ded8f5489ce131a0903c684709b9 | /src/main/java/leetcode/solutions/April Code/GlobalLocalInversions.java | 21d01ee57674223bff9f17ccf4d53c023d81d971 | [
"Apache-2.0"
] | permissive | BrahianVT/LeetcodeProblems | e01e4c238412060e6c9ece532b0c42f3737ac6ea | 8346f2df6727aff7968419d74b95715954f70029 | refs/heads/master | 2023-08-02T02:53:43.770997 | 2021-10-01T16:37:17 | 2021-10-01T16:37:17 | 283,952,512 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 391 | java |
package leetcode.solutions;
import java.util.*;
/*
5
Number leecode problem:775
https://leetcode.com/problems/global-and-local-inversions/
Time Complexity: O(n)
Space Complexity: O(1)
*/
public class GlobalLocalInversions{
public boolean isIdealPermutation(int[] A) {
for(int i = 0; i < A.length; i++){
if(Math.abs(i - A[i]) > 1)return false;
}
return true;
}
} | [
"[email protected]"
] | |
720448ab233fb863551c9e771336d59561eae5ed | 930d9ae2fc71c87c2b157b15b8a664f8884201a5 | /QuickNews/.apt_generated/com/tiger/quicknews/activity/PhotoDetailActivity_.java | 13332f64e27d3a2cb7836aefa321c01ddd0871f0 | [] | no_license | tigerguixh/QuickNews | 040eb7eb51c1be0a44e46cfcfede7a08ed696aa0 | 159c29b87f1e6807ecb071626a34b56cbe73b62e | refs/heads/tiger | 2021-06-28T10:51:00.285408 | 2019-02-27T06:58:00 | 2019-02-27T06:58:00 | 23,054,709 | 789 | 526 | null | 2017-04-11T04:31:12 | 2014-08-18T01:27:45 | Java | UTF-8 | Java | false | false | 5,319 | java | //
// DO NOT EDIT THIS FILE, IT HAS BEEN GENERATED USING AndroidAnnotations 3.1.
//
package com.tiger.quicknews.activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import com.tiger.quicknews.R.id;
import com.tiger.quicknews.R.layout;
import com.tiger.quicknews.adapter.PhotoDetailAdapter_;
import com.tiger.quicknews.wedget.flipview.FlipView;
import org.androidannotations.api.BackgroundExecutor;
import org.androidannotations.api.SdkVersionHelper;
import org.androidannotations.api.builder.ActivityIntentBuilder;
import org.androidannotations.api.view.HasViews;
import org.androidannotations.api.view.OnViewChangedListener;
import org.androidannotations.api.view.OnViewChangedNotifier;
public final class PhotoDetailActivity_
extends PhotoDetailActivity
implements HasViews, OnViewChangedListener
{
private final OnViewChangedNotifier onViewChangedNotifier_ = new OnViewChangedNotifier();
private Handler handler_ = new Handler(Looper.getMainLooper());
@Override
public void onCreate(Bundle savedInstanceState) {
OnViewChangedNotifier previousNotifier = OnViewChangedNotifier.replaceNotifier(onViewChangedNotifier_);
init_(savedInstanceState);
super.onCreate(savedInstanceState);
OnViewChangedNotifier.replaceNotifier(previousNotifier);
setContentView(layout.activity_photo);
}
private void init_(Bundle savedInstanceState) {
OnViewChangedNotifier.registerOnViewChangedListener(this);
photoDetailAdapter = PhotoDetailAdapter_.getInstance_(this);
init();
}
@Override
public void setContentView(int layoutResID) {
super.setContentView(layoutResID);
onViewChangedNotifier_.notifyViewChanged(this);
}
@Override
public void setContentView(View view, LayoutParams params) {
super.setContentView(view, params);
onViewChangedNotifier_.notifyViewChanged(this);
}
@Override
public void setContentView(View view) {
super.setContentView(view);
onViewChangedNotifier_.notifyViewChanged(this);
}
public static PhotoDetailActivity_.IntentBuilder_ intent(Context context) {
return new PhotoDetailActivity_.IntentBuilder_(context);
}
public static PhotoDetailActivity_.IntentBuilder_ intent(android.app.Fragment fragment) {
return new PhotoDetailActivity_.IntentBuilder_(fragment);
}
public static PhotoDetailActivity_.IntentBuilder_ intent(android.support.v4.app.Fragment supportFragment) {
return new PhotoDetailActivity_.IntentBuilder_(supportFragment);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (((SdkVersionHelper.getSdkInt()< 5)&&(keyCode == KeyEvent.KEYCODE_BACK))&&(event.getRepeatCount() == 0)) {
onBackPressed();
}
return super.onKeyDown(keyCode, event);
}
@Override
public void onViewChanged(HasViews hasViews) {
mFlipView = ((FlipView) hasViews.findViewById(id.flip_view));
initView();
}
@Override
public void getResult(final String result) {
handler_.post(new Runnable() {
@Override
public void run() {
PhotoDetailActivity_.super.getResult(result);
}
}
);
}
@Override
public void loadPhotoList(final String url) {
BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0, "") {
@Override
public void execute() {
try {
PhotoDetailActivity_.super.loadPhotoList(url);
} catch (Throwable e) {
Thread.getDefaultUncaughtExceptionHandler().uncaughtException(Thread.currentThread(), e);
}
}
}
);
}
public static class IntentBuilder_
extends ActivityIntentBuilder<PhotoDetailActivity_.IntentBuilder_>
{
private android.app.Fragment fragment_;
private android.support.v4.app.Fragment fragmentSupport_;
public IntentBuilder_(Context context) {
super(context, PhotoDetailActivity_.class);
}
public IntentBuilder_(android.app.Fragment fragment) {
super(fragment.getActivity(), PhotoDetailActivity_.class);
fragment_ = fragment;
}
public IntentBuilder_(android.support.v4.app.Fragment fragment) {
super(fragment.getActivity(), PhotoDetailActivity_.class);
fragmentSupport_ = fragment;
}
@Override
public void startForResult(int requestCode) {
if (fragmentSupport_!= null) {
fragmentSupport_.startActivityForResult(intent, requestCode);
} else {
if (fragment_!= null) {
fragment_.startActivityForResult(intent, requestCode);
} else {
super.startForResult(requestCode);
}
}
}
}
}
| [
"[email protected]"
] | |
fe5bdaab81036fab92c9b3e0e5c557810e74ab62 | d6084cff6b3a943e3bb70b34ea8c330d7e39067e | /Dry_Cleaning_Manager/src/mainpackage/CleaningMachine.java | e68d7b78d7c51aee3a6fc7d8a46aec6c94105200 | [] | no_license | etzellux/Dry_Cleaning_Manager | b3e1354a3d382f2a2e6f81f12c969116ff63d9e2 | a2f78015a9dd9db5fda9ca2544bb95087e5545e3 | refs/heads/main | 2023-04-22T09:22:00.500517 | 2021-05-13T12:42:18 | 2021-05-13T12:42:18 | 350,010,871 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 674 | java |
package mainpackage;
/**
*
* @author etzellux
*/
public class CleaningMachine extends Machine
{
private static int cmNum = 0;
private String cTypeOfWL = "empty";
public CleaningMachine(int id,String name)
{
super(id,name);
cmNum++;
}
public String getCType()
{
return cTypeOfWL;
}
public void setCType(String type)
{
cTypeOfWL = type;
}
public int getCMNum()
{
return cmNum;
}
public String toString()
{
String msg = "id:" + id + "\nname:" + name + "\ntype: Cleaning Machine" + "\nnumber of loads:" + wlNum;
return msg;
}
}
| [
"[email protected]"
] | |
92a7a849814bc8d067efde47bf5f8cba533d9014 | 37b1343af31f288c548c6d7704e7bbbca1cab2a8 | /BroadcastGatewayEngine/src/com/ireslab/broadcast/gateway/SimpleVoiceBroadcast.java | bef74591fbfd72b08d741741356d09f3d776d8c3 | [] | no_license | saubhagya1987/myproj3 | 5ccb63ee3896fe0ed2c1b880261078ed8f9dcbe4 | 02424bbdf0695672bf4400318863abaaa7e9f5de | refs/heads/master | 2021-01-13T15:32:10.944419 | 2017-03-17T19:01:30 | 2017-03-17T19:01:30 | 85,320,324 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,145 | java | package com.ireslab.broadcast.gateway;
import java.io.File;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import com.callfire.api.data.AnsweringMachineConfig;
import com.callfire.api.data.Call;
import com.callfire.api.data.IvrBroadcastConfig;
import com.callfire.api.data.Result;
import com.callfire.api.data.ToNumber;
import com.callfire.api.data.VoiceBroadcastConfig;
import com.callfire.api.service.wsdl.CallServicePortType;
import com.callfire.api.service.wsdl.ServiceFault;
import com.callfire.api.service.wsdl.http.soap12.CallFireApi;
import com.callfire.api.service.wsdl.http.soap12.CallFireApi.ServiceState;
import com.callfire.api.service.xsd.ActionQuery;
import com.callfire.api.service.xsd.CallQueryResult;
import com.callfire.api.service.xsd.CreateSound;
import com.callfire.api.service.xsd.SendCall;
/**
* Example implementation of using CallFire's APIs to send a simple voice
* broadcast to multiple contacts.
*
* @author ross
*/
public class SimpleVoiceBroadcast {
private static final Logger LOG = Logger.getLogger(SimpleVoiceBroadcast.class.getName());
private static final File TEST_LIVE_SOUND_FILE = new File("../callfire-api-samples/src/resources/test-sound.mp3");
private static final File TEST_MACHINE_SOUND_FILE = new File("../callfire-api-samples/src/resources/test-sound.mp3");
private int maxWaitMs;
private final CallFireApi callFireApi;
private final CallServicePortType callService;
String userName = "";
String password = "";
String messageByIVR = "";
String fromNumber = "8448835388";
public SimpleVoiceBroadcast(CallFirePropertiesInfo callFirePropertiesInfo) {
maxWaitMs = 50000;
userName = callFirePropertiesInfo.getUserName();
password = callFirePropertiesInfo.getPassword();
callFireApi = new CallFireApi(userName, password, ServiceState.PRODUCTION);
callService = callFireApi.getCallServicePort();
}
/**
* @param txtMsg
* @param toNumbers
* @param fromNumber
* @throws ServiceFault
*/
public long sendVoiceBroadcastUsingCallService(String type, String securityCode, String toNumber,
CallFirePropertiesInfo callFirePropertiesInfo) throws ServiceFault {
String ivrMessage = callFirePropertiesInfo.getIvrMessageForSecurityCode();
// String ivrMessage
// ="<dialplan name=\"Root\"> <play type=\"tts\" voice=\"female2\" name=\"mainOnPick\">Your six digit verification code for Engage is : SAMPLE_CODE</play> <menu maxDigits=\"1\" timeout=\"3500\" name=\"mainMenu\"> <play type=\"tts\" voice=\"female2\" name=\"menuOptions\">Press 1 to repeat. Press any other key to disconnect the call.</play> <keypress pressed=\"1\" name=\"mainOptionRepeat\"> <goto name=\"jumper\">mainOnPick</goto> </keypress> <keypress pressed=\"default\" name=\"nothingToDo\"> <hangup name=\"hangUpNow\"/> </keypress> </menu> </dialplan>";
Long broadcastId = 0L;
// send a single-call IVR broadcast
IvrBroadcastConfig config = new IvrBroadcastConfig();
String ivrMsgToSend = ivrMessage.replaceAll("SAMPLE_CODE", securityCode.replaceAll(".(?!$)", "$0 . "));
LOG.info("IVR message :"+ivrMsgToSend);
config.setDialplanXml(ivrMsgToSend);
config.setFromNumber(fromNumber);
SendCall sendCall = new SendCall();
sendCall.setBroadcastName("Simple Voice Broadcast");
ToNumber toNumberElem = new ToNumber();
toNumberElem.setValue(toNumber);
sendCall.getToNumber().add(toNumberElem);
sendCall.setScrubBroadcastDuplicates(false);
sendCall.setIvrBroadcastConfig(config);
broadcastId = callService.sendCall(sendCall);
return broadcastId;
}
/**
* @param broadcastId
* @param toNumbers
* @return true if Result.SENT is received for each specified toNumber.
*/
private boolean pollForResponse(long broadcastId, List<Object> toNumbers) throws ServiceFault {
LOG.info("polling for call status");
final int sleepInterval = 2000;
int totalWait = 0;
ActionQuery callQuery = new ActionQuery();
callQuery.setBroadcastId(broadcastId);
while (totalWait < maxWaitMs) {
try {
Thread.sleep(sleepInterval);
totalWait += sleepInterval;
} catch (InterruptedException e) {
LOG.log(Level.FINE, "interrupted", e);
}
CallQueryResult result = callService.queryCalls(callQuery);
List<Call> callList = result.getCall();
if (callList.isEmpty()) {
throw new RuntimeException("call query did not return a call");
}
for (Call call : callList) {
Result finalResult = call.getFinalResult();
String toNumber = call.getToNumber().getValue();
if (finalResult != null) {
if (!finalResult.equals(Result.UNDIALED)) {
toNumbers.remove(toNumber);
LOG.info("found toNumber: " + toNumber);
if (toNumbers.isEmpty()) {
return true;
}
}
}
}
}
return false;
}
private long createSound(File soundFile) throws ServiceFault {
CreateSound sound = new CreateSound();
sound.setName("some sound");
DataSource source = new FileDataSource(soundFile);
DataHandler dataHandler = new DataHandler(source);
sound.setData(dataHandler);
long soundId = callService.createSound(sound);
return soundId;
}
/**
* Exercises sending a simple voice broadcast to multiple contacts.
*
* @throws Exception
*/
public void run() throws Exception {
long broadcastId = sendVoiceBroadcastUsingCallService("IVR", "123456", "+15104693350", null);
boolean response = pollForResponse(broadcastId, null);
if (!response) {
LOG.log(Level.WARNING, "did not receive postive reponse.");
} else {
LOG.log(Level.INFO, "received postive reponse.");
}
}
public static void main(String[] args) {
CallFirePropertiesInfo callFirePropertiesInfo = new CallFirePropertiesInfo();
callFirePropertiesInfo.setUserName("f456db1d2ba7");
callFirePropertiesInfo.setPassword("6856c4a87bf885b6");
try {
new SimpleVoiceBroadcast(callFirePropertiesInfo).run();
} catch (Exception e) {
LOG.log(Level.SEVERE, "exception running " + SimpleVoiceBroadcast.class.getName(), e);
}
}
}
| [
"[email protected]"
] | |
963f3a711b03c4754dda09da8205a4bb6f98f3a2 | 601582228575ca0d5f61b4c211fd37f9e4e2564c | /logisoft_revision1/src/com/logiware/form/AccrualMigrationLogForm.java | 6627901cc355889146f0c18ef7a11f262d8cbfc9 | [] | no_license | omkarziletech/StrutsCode | 3ce7c36877f5934168b0b4830cf0bb25aac6bb3d | c9745c81f4ec0169bf7ca455b8854b162d6eea5b | refs/heads/master | 2021-01-11T08:48:58.174554 | 2016-12-17T10:45:19 | 2016-12-17T10:45:19 | 76,713,903 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 3,828 | java | package com.logiware.form;
import com.logiware.hibernate.domain.AccrualMigrationErrorFile;
import com.logiware.hibernate.domain.AccrualMigrationLog;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
/**
*
* @author Lakshmi Narayanan
*/
public class AccrualMigrationLogForm extends ActionForm {
private String action;
private Integer recordsLimit = 100;
private Integer currentPageNo = 1;
private Integer currentNoOfRecords = 0;
private Integer totalPageNo = 0;
private Integer totalNoOfRecords = 0;
private String sortBy = "reportedDate";
private String orderBy = "desc";
private String searchBy;
private String searchValue;
private String fileContent;
private String fromDate;
private String toDate;
private Integer id;
private String logType = "error";
private List<AccrualMigrationLog> logs;
private AccrualMigrationErrorFile accrualMigrationErrorFile;
public AccrualMigrationLogForm() {
accrualMigrationErrorFile = new AccrualMigrationErrorFile();
}
public String getAction() {
return action;
}
public void setAction(String action) {
this.action = action;
}
public Integer getCurrentNoOfRecords() {
return currentNoOfRecords;
}
public void setCurrentNoOfRecords(Integer currentNoOfRecords) {
this.currentNoOfRecords = currentNoOfRecords;
}
public Integer getCurrentPageNo() {
return currentPageNo;
}
public void setCurrentPageNo(Integer currentPageNo) {
this.currentPageNo = currentPageNo;
}
public String getOrderBy() {
return orderBy;
}
public void setOrderBy(String orderBy) {
this.orderBy = orderBy;
}
public Integer getRecordsLimit() {
return recordsLimit;
}
public void setRecordsLimit(Integer recordsLimit) {
this.recordsLimit = recordsLimit;
}
public String getSortBy() {
return sortBy;
}
public void setSortBy(String sortBy) {
this.sortBy = sortBy;
}
public Integer getTotalNoOfRecords() {
return totalNoOfRecords;
}
public void setTotalNoOfRecords(Integer totalNoOfRecords) {
this.totalNoOfRecords = totalNoOfRecords;
}
public Integer getTotalPageNo() {
return totalPageNo;
}
public void setTotalPageNo(Integer totalPageNo) {
this.totalPageNo = totalPageNo;
}
public String getSearchBy() {
return searchBy;
}
public void setSearchBy(String searchBy) {
this.searchBy = searchBy;
}
public String getSearchValue() {
return searchValue;
}
public void setSearchValue(String searchValue) {
this.searchValue = searchValue;
}
public String getFileContent() {
return fileContent;
}
public void setFileContent(String fileContent) {
this.fileContent = fileContent;
}
public String getFromDate() {
return fromDate;
}
public void setFromDate(String fromDate) {
this.fromDate = fromDate;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLogType() {
return logType;
}
public void setLogType(String logType) {
this.logType = logType;
}
public List<AccrualMigrationLog> getLogs() {
return logs;
}
public void setLogs(List<AccrualMigrationLog> logs) {
this.logs = logs;
}
public String getToDate() {
return toDate;
}
public void setToDate(String toDate) {
this.toDate = toDate;
}
public AccrualMigrationErrorFile getAccrualMigrationErrorFile() {
return accrualMigrationErrorFile;
}
public void setAccrualMigrationErrorFile(AccrualMigrationErrorFile accrualMigrationErrorFile) {
this.accrualMigrationErrorFile = accrualMigrationErrorFile;
}
}
| [
"[email protected]"
] | |
b3555b249a2187129c680bfb0104f3a665885482 | d73c9e0789a8f28e160306db05d5de3ab5658b5f | /src/main/java/by/bsuir/service/StatusService.java | b581189b1489e5e6264a11a395feb4822af038e1 | [] | no_license | skalashynski/diploma | e3b876580ce4a0ac70d2f242eccd010512d9c62a | 2cd65fb2dee6d018cb9213b921ad1405c2c83b0c | refs/heads/master | 2022-07-17T21:06:20.175510 | 2020-05-22T09:58:44 | 2020-05-22T09:58:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 168 | java | package by.bsuir.service;
import by.bsuir.entity.FlatStatus;
import by.bsuir.entity.FlatStatus;
public interface StatusService {
FlatStatus getStatus(Long id);
}
| [
"[email protected]"
] | |
dc440321626b3fcedd8da461a75420f174d6c206 | 4ba14a2fd91860f48a1280180df1bfe670643e04 | /restaurant-core/src/main/java/hu/unideb/inf/rft/restaurant/core/entitiy/BaseEntity.java | 95d0925978ba494f05380fb2fce079bfce0d60f2 | [] | no_license | rft-team3/restaurant | 85fd3cd990dfbbe7cef767466e3431520bec8a11 | 6cc831ddae34bc77228cf1480b88faa27842475b | refs/heads/master | 2021-01-10T23:46:15.154557 | 2016-12-19T21:59:55 | 2016-12-19T21:59:55 | 70,402,848 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 940 | java | package hu.unideb.inf.rft.restaurant.core.entitiy;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import java.io.Serializable;
@MappedSuperclass
public class BaseEntity implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BaseEntity that = (BaseEntity) o;
return getId().equals(that.getId());
}
@Override
public int hashCode() {
return getId().hashCode();
}
}
| [
"[email protected]"
] | |
d685c90a6ae10da5afeb116611cb64fcc8d49e30 | 6d82f06048d330216b17c19790f29075e62e47d5 | /tags/SDK-1.0.0/lab/job/api/src/main/net/dpml/job/CommissionerController.java | 7c960f3c472d045b29e935d16a7d355ab44b6316 | [] | no_license | IdelsTak/dpml-svn | 7d1fc3f1ff56ef2f45ca5f7f3ae88b1ace459b79 | 9f9bdcf0198566ddcee7befac4a3b2c693631df5 | refs/heads/master | 2022-03-19T15:50:45.872930 | 2009-11-23T08:45:39 | 2009-11-23T08:45:39 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,438 | java | /*
* Copyright 2006 Stephen J. McConnell.
*
* 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 net.dpml.job;
import java.lang.reflect.InvocationTargetException;
/**
* Interface implemented by commissioner controllers.
* @author <a href="@PUBLISHER-URL@">@PUBLISHER-NAME@</a>
* @version @PROJECT-VERSION@
*/
public interface CommissionerController
{
/**
* Notification that a commissioning or decommissioning
* process has commenced.
* @param event the commissioner event
*/
void started( CommissionerEvent event );
/**
* Notification that a commissioning or decommissioning
* process has successfully completed.
* @param event the commissioner event
*/
void completed( CommissionerEvent event );
/**
* Notification that a commissioning or decommissioning
* process has been interrupted.
* @param event the commissioner event
* @exception TimeoutException optional controller initiated exception
*/
void interrupted( CommissionerEvent event ) throws TimeoutException;
/**
* Notification that a commissioning or decommissioning
* process has failed due to a timeout and the target commissionable
* object failed to resopond to an interrup and was subsequently
* terminated.
* @param event the commissioner event
* @param cause the causal exception
* @exception InvocationTargetException optional wrapped client exception
*/
void failed( CommissionerEvent event, Throwable cause ) throws InvocationTargetException;
/**
* Notification that a commissioning or decommissioning
* process has failed.
* @param event the commissioner event
* @exception TimeoutError optional controller initiated timeout error
*/
void terminated( CommissionerEvent event ) throws TimeoutError;
}
| [
"mcconnell@00579e91-1ffa-0310-aa18-b241b61564ef"
] | mcconnell@00579e91-1ffa-0310-aa18-b241b61564ef |
f2991915aab81e91f80558ce5d429d2eccbe1dd6 | add2305d3f9847574c4af35d9d8cdc6fea0e6271 | /ch12/PastReadInt.java | 031db81249e9b78c94c83295cd777842eed31f89 | [] | no_license | ekdms342/java | 05201e7b39032667a81eafca9906cf283e9049ec | 31a3280ef57f23e1b046d454ab346a63bf6946ef | refs/heads/master | 2022-10-05T08:26:25.141463 | 2020-06-12T07:11:52 | 2020-06-12T07:11:52 | 255,220,609 | 0 | 0 | null | null | null | null | UHC | Java | false | false | 420 | java | import java.io.*;
class PastReadInt {
public static void main (String []args)
{
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.print("정수 입력: ");
String str = br.readLine();
int num = Integer.parseInt(str);
System.out.println("입력된 정수: " +num);
}catch(Exception ex) {
ex.printStackTrace();
}
}
}
| [
"[email protected]"
] | |
0aebbfb5925ef7b54d54e54b1fbbd01c50f75d1c | 5b047d621f09f362210cc30ab272baa0acc8f8c2 | /src/main/java/com/example/tutosSpringBoot/reactiveProgramming/coreExamples/Example2.java | d2411521d251601f673038a2932be03dfeda6c97 | [] | no_license | ZITOUNIMED/AdvancedSpringBootProject | 04005cae422674a061038bc96647d2964ff2ee44 | 92adf7d25c008ad41cddaf63197a8de5abc24984 | refs/heads/master | 2023-05-06T03:56:33.362079 | 2021-05-26T18:47:57 | 2021-05-26T18:47:57 | 370,625,323 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 789 | java | package com.example.tutosSpringBoot.reactiveProgramming.coreExamples;
import java.util.ArrayList;
import java.util.List;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
public class Example2 {
public static void main(String[] args) {
Integer[] data1 = {1, 2, 3, 4, 5, 6, 7};
Integer[] data2 = {10, 20, 30, 40, 50, 60, 70};
Flux.just(data1)
.zipWith(Flux.just(data2))
.subscribe(System.out::println); // [1,10] ...
List<Integer> elements = new ArrayList<>();
// Concurrency
Flux.range(1, 50)
.map(i -> i * 2)
.subscribeOn(Schedulers.parallel())
.log()
.subscribe(elements::add);
System.out.println(elements); // [] ???
}
}
| [
"[email protected]"
] | |
d1986c1244e76ba5871ed811533063382c24f7eb | ac0472a885a0696ba0419f3e5582b005e155b138 | /template-manager/template-app/src/main/java/com/mes/common/dao/MsgTemplateMapper.java | 88ae8b9e7a9f18c2e1301afd54c623d33491a167 | [] | no_license | liukunlong1093/base-cloud | 4739fa4796ff59d782d06e22139f0565a06acfd4 | afe7e21e3ef58840611e65e6b023e67f8a5e9629 | refs/heads/master | 2021-04-09T13:38:21.698215 | 2018-04-28T07:20:49 | 2018-04-28T07:20:49 | 125,459,705 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,653 | java | package com.mes.common.dao;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import com.mes.common.dto.MsgTemplateDTO;
/**
* 项目名称: [template-app]
* 包: [com.mes.common.dao]
* 类名称: [UserMapper]
* 类描述: [消息模板数据映射接口]
* 创建人: [刘坤龙]
* 创建时间: [2017年8月24日 上午11:45:34]
* 修改人: [刘坤龙]
* 修改时间: [2017年8月24日 上午11:45:34]
* 修改备注: [说明本次修改内容]
* 版本: [v1.0]
*/
@Mapper
public interface MsgTemplateMapper {
/**
* 根据消息模板标识获取消息模板
* @param id 消息模板标识
* @return 消息模板对象
*/
MsgTemplateDTO getMsgTemplateById(Long id);
/**
* 根据条件获取消息模板列表
* @param condition 查询条件
* @return 消息模板列表
*/
List<MsgTemplateDTO> getMsgTemplateList(Map<String, Object> condition);
/**
* 保存消息模板
* @param msgTemplateDTO 消息模板对象
* @return 新增成功条数
*/
long saveMsgTemplate(MsgTemplateDTO msgTemplateDTO);
/**
* 更新消息模板
* @param msgTemplateDTO 消息模板对象
* @return 更新成功条数
*/
long updateMsgTemplate(MsgTemplateDTO msgTemplateDTO);
/**
* 根据消息模板标识删除消息模板
* @param id 消息模板标识
* @return 删除成功条数
*/
long deleteMsgTemplateById(Long id);
/**
* 批量保存消息模板
* @param msgTemplateList 消息模板数据集合
* @return 新增成功条数
*/
long batchSaveMsgTemplate(List<MsgTemplateDTO> msgTemplateList);
}
| [
"[email protected]"
] | |
ddfe44eda5636b5f56630fa2cf9a24579514b34b | 012e97108ccf440be8f8ff51b27f2ac3ba72706c | /T2_alg2_grafos/src/Pais.java | bc97838651fad6fae9d046a8c6df11afde848c04 | [] | no_license | matheuslfb/T2_grafos | 11a35a8a24b1be146cc5a25efcfd7297ef35bca2 | 96c04add3585633fc7d6e9bd9b31013dfa104d70 | refs/heads/master | 2020-04-05T12:09:49.932155 | 2017-07-04T23:03:54 | 2017-07-04T23:03:54 | 95,242,143 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 404 | java | import java.io.Serializable;
public class Pais implements Serializable {
private static final long serialVersionUID = 7968808410731767025L;
private String codigo;
private String nome;
public Pais(String codigo, String nome) {
this.codigo = codigo;
this.nome = nome;
}
public String getCodigo() {
return codigo;
}
public String getNome() {
return nome;
}
}
| [
"[email protected]"
] | |
a4c101b3335b60eb4d72cda9c19ed8e5af449e13 | 822818db04430597dc82ee060db1560796518990 | /web/jdbctest/src/com/kitri/jdbctest/DeleteTest.java | 5e8453929e4cb76a6810c798f66d4a444a11ed56 | [] | no_license | zave7/java | 51089a59878c5f47cd047d88492422eeb220162d | 8001db24ed14b689333663c4fd484803e1021ecd | refs/heads/master | 2023-04-09T19:06:38.817904 | 2023-03-27T06:41:16 | 2023-03-27T06:41:16 | 173,880,309 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,578 | java | package com.kitri.jdbctest;
import java.io.*;
import java.sql.*;
import java.util.Properties;
public class DeleteTest {
public DeleteTest() {
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
System.out.println("Driver Loading Success!!");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
private Connection makeConnection() throws FileNotFoundException, IOException, SQLException {
Connection conn = null;
Properties prop = new Properties();
prop.load(new FileReader(new File("src/com/kitri/jdbctest/test.properties")));
conn = DriverManager.getConnection("jdbc:oracle:thin:@192.168.14.52:1521:orcl", prop);
return conn;
}
public static void main(String[] args) {
DeleteTest dt = new DeleteTest();
Connection conn = null;
Statement stmt = null;
int cnt = 0;
try {
conn = dt.makeConnection();
String name = "내아래로모여";
String sql = "delete jdbctest \n";
sql += "where name = '" + name + "'";
stmt = conn.createStatement();
cnt = stmt.executeUpdate(sql);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if(stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
System.out.println(cnt + "개 delete!!");
}
}
| [
"[email protected]"
] | |
f7ca46ff8cf73609d9e6fddc48b289b1713f7327 | 67b3f1bdc351d8d64937668418db955f6b7283b1 | /src/main/java/cn/bestrivenlf/myweb/component/MyRealm.java | c4d3da466191a0e5c868d8184db462dd13f4f3bf | [] | no_license | Liu98Fan/myBlog | f0ec611aeda5dcdd7374ebf2c7ef34855a182112 | dde40a1798e9c7953a71ba02d31c71e9ed5901a9 | refs/heads/master | 2020-04-06T13:43:23.653889 | 2019-04-04T02:46:26 | 2019-04-04T02:46:26 | 157,511,829 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,099 | java | package cn.bestrivenlf.myweb.component;
import cn.bestrivenlf.myweb.entity.Role;
import cn.bestrivenlf.myweb.entity.User;
import cn.bestrivenlf.myweb.interfaceService.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import javax.servlet.http.HttpSession;
import java.util.List;
import java.util.Set;
public class MyRealm extends AuthorizingRealm {
@Autowired
private UserService userService;
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
User user = (User) principalCollection.getPrimaryPrincipal();
Set<Role> roles = user.getRoleConvertSet();
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setStringPermissions(user.getPermissionCovertStringSet());
info.setRoles(user.getRoleConvertStringSet());
return info;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
String username = token.getUsername();
User user = userService.getUserByUserName(username);
if(user!=null){
//查到相关信息
Object principal = user;
//这里的密码是从数据库查询出来的正确的密码
String credential = user.getPassword();
String realmName = super.getName();
// public SimpleAuthenticationInfo(Object principal, Object hashedCredentials, ByteSource credentialsSalt, String realmName)
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principal,credential,realmName);
return info;
}else{
throw new UnknownAccountException("账号不存在");
}
}
}
| [
"bestrivenlf"
] | bestrivenlf |
ef55c422f7b737db8c3db86d36846ff260e0464d | 71f1b50351f1e20576e1fc8c70f2068020e0a30a | /src/main/java/org/jensoft/catalog/views/intro/breakpoint/RealtimeCloudBreakpoint.java | 5c4db3e8e8b8fbc8da828fdbdd4f7f0f90abb4de | [] | no_license | neuroradiology/jensoft-samples | f2411d8771c658a555151e37991a9a8b81b7cb51 | cb939e86a25f649fc4dc9c86a4e84967bb8a9227 | refs/heads/master | 2021-01-24T02:59:28.935239 | 2017-05-28T22:17:44 | 2017-05-28T22:17:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,240 | java | /*
* JenSoft API - Charting Framework
* http://www.jensoftapi.com
* Copyright (c) JenSoft. All rights reserved.
* See JenSoft Software License Agreement
*/
package org.jensoft.catalog.views.intro.breakpoint;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import org.jensoft.catalog.views.intro.DemoBreakPoint;
import org.jensoft.catalog.views.intro.JenSoftBreackpointExecutor;
import org.jensoft.core.graphics.Antialiasing;
import org.jensoft.core.palette.color.Alpha;
import org.jensoft.core.palette.color.ColorPalette;
import org.jensoft.core.palette.color.FilPalette;
import org.jensoft.core.palette.color.RosePalette;
import org.jensoft.core.plugin.AbstractPlugin;
import org.jensoft.core.plugin.background.DeviceNightBackground;
import org.jensoft.core.plugin.grid.Grid.GridOrientation;
import org.jensoft.core.plugin.grid.GridPlugin;
import org.jensoft.core.plugin.legend.title.TitleLegend;
import org.jensoft.core.plugin.legend.title.TitleLegendConstraints;
import org.jensoft.core.plugin.legend.title.TitleLegendConstraints.LegendAlignment;
import org.jensoft.core.plugin.legend.title.TitleLegendConstraints.LegendPosition;
import org.jensoft.core.plugin.legend.title.TitleLegendPlugin;
import org.jensoft.core.plugin.legend.title.painter.fil.TitleLegendGradientFill;
import org.jensoft.core.plugin.marker.MarkerPlugin;
import org.jensoft.core.plugin.marker.context.MarkerDefaultDeviceContext;
import org.jensoft.core.plugin.metrics.AxisMetricsPlugin;
import org.jensoft.core.plugin.outline.OutlinePlugin;
import org.jensoft.core.plugin.stripe.StripePlugin;
import org.jensoft.core.plugin.stripe.painter.StripePalette;
import org.jensoft.core.plugin.translate.TranslateCompassWidget;
import org.jensoft.core.plugin.translate.TranslateCompassWidget.CompassStyle;
import org.jensoft.core.plugin.translate.TranslateDefaultDeviceContext;
import org.jensoft.core.plugin.translate.TranslatePlugin;
import org.jensoft.core.plugin.translate.TranslateX;
import org.jensoft.core.plugin.translate.TranslateY;
import org.jensoft.core.plugin.zoom.box.ZoomBoxDefaultDeviceContext;
import org.jensoft.core.plugin.zoom.box.ZoomBoxPlugin;
import org.jensoft.core.plugin.zoom.lens.LensDefaultDeviceContext;
import org.jensoft.core.plugin.zoom.lens.LensX;
import org.jensoft.core.plugin.zoom.lens.LensY;
import org.jensoft.core.plugin.zoom.lens.ZoomLensPlugin;
import org.jensoft.core.plugin.zoom.percent.ZoomPercentDefaultDeviceContext;
import org.jensoft.core.plugin.zoom.percent.ZoomPercentPlugin;
import org.jensoft.core.plugin.zoom.wheel.ZoomWheelPlugin;
import org.jensoft.core.projection.Projection;
import org.jensoft.core.view.View;
import org.jensoft.core.view.ViewPart;
import org.jensoft.core.view.WidgetPlugin.PushingBehavior;
public class RealtimeCloudBreakpoint extends DemoBreakPoint {
public RealtimeCloudBreakpoint(JenSoftBreackpointExecutor jenSoftDemoExecutor, View view) {
super(jenSoftDemoExecutor, view);
}
@Override
protected DemoMessage getMessage() {
DemoMessage msg = new DemoMessage("Continue and install cloud point.");
msg.setSize(320, 110);
msg.setTitle("JenSoft API - Cloud Points");
msg.setMessageTitleColor(Color.WHITE);
msg.setMessageForeground(Color.WHITE);
return msg;
}
@Override
public void run() {
super.run();
try {
synchronized (this) {
Font f = new Font("Dialog", Font.PLAIN, 14);
view.getWidgetPlugin().pushMessage("Install Cloud", 500, null, PushingBehavior.Fast, f, Color.BLACK);
wait(500);
Projection proj = new Projection.Linear(-3000, 3000, -2500, 2500);
proj.setThemeColor(RosePalette.SAFFRON);
proj.setName("constellation proj");
proj.registerPlugin(new DeviceNightBackground());
Font f12 = new Font("Dialog", Font.PLAIN, 12);
AxisMetricsPlugin.ModeledMetrics westMetrics = new AxisMetricsPlugin.ModeledMetrics.W();
proj.registerPlugin(westMetrics);
westMetrics.setTextFont(f12);
AxisMetricsPlugin.ModeledMetrics southMetrics = new AxisMetricsPlugin.ModeledMetrics.S();
proj.registerPlugin(southMetrics);
southMetrics.setTextFont(f12);
proj.registerPlugin(new OutlinePlugin());
TitleLegend legend = new TitleLegend("Measures");
legend.setLegendFill(new TitleLegendGradientFill(RosePalette.EMERALD, RosePalette.COALBLACK));
legend.setFont(f);
legend.setConstraints(new TitleLegendConstraints(LegendPosition.East, 0.3f, LegendAlignment.Rigth));
TitleLegendPlugin legendPlugin = new TitleLegendPlugin(legend);
proj.registerPlugin(legendPlugin);
StripePlugin bandLayout = new StripePlugin.MultiplierStripe.H(-200, 400);
StripePalette bp = new StripePalette();
bp.addPaint(new Color(255, 255, 255, 40));
bp.addPaint(ColorPalette.alpha(FilPalette.GREEN5, 120));
bandLayout.setStripePalette(bp);
bandLayout.setAlpha(0.1f);
proj.registerPlugin(bandLayout);
GridPlugin gridLayout = new GridPlugin.MultiplierGrid(-200, 400, GridOrientation.Horizontal);
gridLayout.setGridColor(new Color(255, 255, 255, 60));
proj.registerPlugin(gridLayout);
// ZOOM BOX
ZoomBoxPlugin zoomBox = new ZoomBoxPlugin();
zoomBox.registerContext(new ZoomBoxDefaultDeviceContext());
proj.registerPlugin(zoomBox);
// TRANSLATE
TranslatePlugin translatePlugin = new TranslatePlugin();
proj.registerPlugin(translatePlugin);
// use pad widget with objectif
TranslateX tx = new TranslateX(80, 12);
tx.setButton1DrawColor(RosePalette.MANDARIN);
tx.setButton2DrawColor(RosePalette.MANDARIN);
TranslateY ty = new TranslateY(12, 80);
ty.setButton1DrawColor(RosePalette.MANDARIN);
ty.setButton2DrawColor(RosePalette.MANDARIN);
translatePlugin.registerWidget(tx, ty);
TranslateCompassWidget compass = new TranslateCompassWidget();
translatePlugin.registerWidget(compass);
compass.setRingFillColor(new Alpha(RosePalette.EMERALD, 150));
compass.setRingDrawColor(Color.WHITE);
compass.setRingNeedleFillColor(new Alpha(RosePalette.EMERALD, 150));
compass.setRingNeedleDrawColor(Color.WHITE);
compass.setCompassStyle(CompassStyle.Separate);
// pre lock selected
translatePlugin.lockSelected();
translatePlugin.registerContext(new TranslateDefaultDeviceContext());
// plugin/objectif
ZoomLensPlugin zoomObjectif = new ZoomLensPlugin();
// plugin/objectif/widget
LensX xObjectif = new LensX(80, 12);
LensY yObjectif = new LensY(12, 80);
zoomObjectif.registerWidget(xObjectif);
zoomObjectif.registerWidget(yObjectif);
// plugin/objectif/context
zoomObjectif.registerContext(new LensDefaultDeviceContext());
proj.registerPlugin(zoomObjectif);
// ZOOM PERCENT
ZoomPercentPlugin zoomPercent = new ZoomPercentPlugin();
zoomPercent.registerContext(new ZoomPercentDefaultDeviceContext());
proj.registerPlugin(zoomPercent);
ZoomWheelPlugin zoomWheel = new ZoomWheelPlugin();
proj.registerPlugin(zoomWheel);
MarkerPlugin markerPlugin = new MarkerPlugin();
markerPlugin.registerContext(new MarkerDefaultDeviceContext());
proj.registerPlugin(markerPlugin);
CloudPlugin constellationLayout = new CloudPlugin();
constellationLayout.setConstellationColor(RosePalette.MANDARIN);
proj.registerPlugin(constellationLayout);
view.registerProjection(proj);
view.repaintView();
ConstellationAnimator demoThread = new ConstellationAnimator(loadShoots(), constellationLayout);
demoThread.start();
demoThread.join();
view.unregisterProjection(proj);
view.setVisible(true);
view.repaintView();
}
} catch (InterruptedException e) {
} finally {
System.out.println("out executor : " + getClass().getSimpleName());
}
}
public class CloudPlugin extends AbstractPlugin {
public CloudPlugin() {
setName("CloudPoint");
}
private Cloud curentCloud = new Cloud();
@Override
protected void paintPlugin(View v2d, Graphics2D g2d, ViewPart viewPart) {
if (curentCloud == null || curentCloud.userPoint == null) {
return;
}
if (viewPart != ViewPart.Device) {
return;
}
if (getCloudColor() == null) {
g2d.setColor(getThemeColor());
} else {
g2d.setColor(getCloudColor());
}
Antialiasing aa = Antialiasing.On;
aa.configureGraphics(g2d);
curentCloud.devicePoint = new ArrayList<Point2D>();
for (int i = 0; i < curentCloud.userPoint.size(); i++) {
Point2D p2dUser = curentCloud.userPoint.get(i);
if (getProjection().intercept(p2dUser)) {
Point2D p2dDevice = null;
p2dDevice = getProjection().userToPixel(p2dUser);
curentCloud.devicePoint.add(p2dDevice);
g2d.drawLine((int) p2dDevice.getX(), (int) p2dDevice.getY(), (int) p2dDevice.getX(), (int) p2dDevice.getY());
}
}
}
public void setCloud(List<Point2D> userPoints) {
curentCloud.userPoint = userPoints;
getProjection().getDevice2D().repaintDevice();
}
private Color cloudColor;
public Color getCloudColor() {
return cloudColor;
}
public void setConstellationColor(Color constellationColor) {
this.cloudColor = constellationColor;
}
class Cloud {
List<Point2D> userPoint;
List<Point2D> devicePoint;
}
}
class ConstellationAnimator extends Thread {
private CloudPlugin plugin;
private Vector<Vector<Point2D>> shoots;
public ConstellationAnimator(Vector<Vector<Point2D>> shoots, CloudPlugin plugin) {
setName("Constellation demo Thread");
this.shoots = shoots;
this.plugin = plugin;
}
@Override
public void run() {
try {
long flagTime = 1000 * 10;
long startMillis = System.currentTimeMillis();
boolean flagrun = true;
while (flagrun || !interrupted()) {
for (int i = 0; i < shoots.size(); i++) {
long currentDuration = System.currentTimeMillis() - startMillis;
if (currentDuration > flagTime) {
flagrun = false;
interrupt();
}
Vector<Point2D> shoot = shoots.get(i);
plugin.setCloud(shoot);
Thread.sleep(150);
}
}
} catch (Exception e) {
}
}
}
private Vector<Vector<Point2D>> loadShoots() {
Vector<Vector<Point2D>> shoots = new Vector<Vector<Point2D>>();
try {
// ClassLoader cloader = getClass().getClassLoader();
InputStream is = getClass().getResourceAsStream("monitoring-input1.txt");
InputStreamReader isreader = new InputStreamReader(is);
BufferedReader in = new BufferedReader(isreader);
String line = null;
while ((line = in.readLine()) != null) {
String c = line.substring(7, line.length() - 1);
Vector<Point2D> v = loadCloud(c);
shoots.add(v);
}
} catch (Exception e) {
System.err.println("Cannot load ad resource " + "monitoring-input1.txt" + " from class " + getClass());
e.printStackTrace();
}
return shoots;
}
private Vector<Point2D> loadCloud(String constellation) {
Vector<Point2D> cVector = new Vector<Point2D>();
boolean empty = false;
while (!empty) {
int openCrochet = constellation.indexOf("[");
int closeCrochet = constellation.indexOf("]");
if (openCrochet == -1) {
empty = true;
} else {
String point = constellation.substring(openCrochet, closeCrochet + 1);
Point2D cp = loadXYPoint(point);
cVector.add(cp);
constellation = constellation.substring(closeCrochet + 1);
}
}
return cVector;
}
private Point2D loadXYPoint(String spoint) {
String[] P = null;
try {
String p = spoint.substring(1, spoint.length() - 1);
P = p.split(",");
} catch (StringIndexOutOfBoundsException e) {
e.printStackTrace();
}
return new Point2D.Double(Double.parseDouble(P[0]), Double.parseDouble(P[1]));
}
}
| [
"[email protected]"
] | |
aeff2a7f4ae9c94e8c77c4d84fc053f9c595d6e8 | f0745bf784e14b1660ea5f1e31b0ff9e72805783 | /Farmacia/src/main/java/br/org/generation/farmacia/model/CategoriaModel.java | 5ebb9fe3996b35bc43c7964f2098fe2bff95e3ed | [
"Apache-2.0"
] | permissive | thaisspereira/SpringBoot | be2d0e402d6eec4cd3981dd9f19dc03e889c04d8 | 88b377d347dcb3890a3b8917a27545f488570bd5 | refs/heads/main | 2023-09-06T06:56:30.050197 | 2021-11-18T22:05:10 | 2021-11-18T22:05:10 | 429,592,642 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,224 | java | package br.org.generation.farmacia.model;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "tb_categoria")
public class CategoriaModel {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@NotBlank (message = "Campo não pode ser nulo")
@Size(min = 5, max = 100)
private String tipo;
private Boolean envio = true;
@OneToMany(mappedBy = "categoria", cascade = CascadeType.ALL)
@JsonIgnoreProperties("categoria")
private List <ProdutoModel> produto ;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public Boolean getEnvio() {
return envio;
}
public void setEnvio(Boolean envio) {
this.envio = envio;
}
}
| [
"[email protected]"
] | |
f2a9ab3a9dc3752f3c62385175f5ccb27315bdea | b767a199fc38bd84806b1352ff332b7c3861d826 | /MultiplicacionRusa/src/multiplicacionrusa/Rusa.java | a0491eb896bbe9ef22c25c8f44be3db8f54bbd05 | [] | no_license | CYetlanezi/MultiplicacionRusa | 2303e2e5cedd83dcad80da809825e5ffb9d10bf5 | 8b0fde53c82cc7af76152ee61e0f08f70537368a | refs/heads/master | 2021-01-21T06:33:07.425021 | 2017-02-27T00:52:41 | 2017-02-27T00:52:41 | 83,253,482 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,073 | java | package multiplicacionrusa;
/**
*
* @author Claudia
*/
public class Rusa extends Lista<Integer> {
private Lista<Integer> res;
public Rusa() {
super();
res = new Lista<Integer>();
}
public Integer suma(Lista<Integer> div2, Lista<Integer> mul2){
Nodo<Integer> primdiv = div2.prim;
Nodo<Integer> primmul = mul2.prim;
Nodo<Integer> primres;
Integer resTotal = 0;
while(primdiv != null){
if(primdiv.info % 2 == 1)
res.insertaFinal(primmul.info);
primdiv = primdiv.sig;
primmul = primmul.sig;
}
primres = res.prim;
while(primres != null){
resTotal += primres.info;
primres = primres.sig;
}
return resTotal;
}
}
| [
"[email protected]"
] | |
2afc886830956f148858a6bd81f31110b98e3b20 | 762d64026ca46dd55de9be590090da1cbab28a03 | /android/app/src/main/java/com/mobilecloud/react/modules/NativePackage.java | de744c9f743f32045c158d2387d1a5b1f5822fc9 | [] | no_license | thingRoll/MobileCloud | be67e2eebe3f51b37a1f80312fa9a96486e042d8 | e55e7e5a5b3f5894dba3f498626f0892017d7b71 | refs/heads/master | 2023-04-30T10:34:10.304178 | 2018-11-08T09:56:01 | 2018-11-08T09:56:01 | 628,615,535 | 0 | 0 | null | 2023-04-20T16:02:15 | 2023-04-16T14:02:47 | null | UTF-8 | Java | false | false | 996 | java | package com.mobilecloud.react.modules;
import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.JavaScriptModule;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Created by WUGUOKAI on 2017/8/28.
*/
public class NativePackage implements ReactPackage {
@Override
public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
List<NativeModule> modules = new ArrayList<>();
modules.add(new NativeManager(reactContext) );
return modules;
}
@Override
public List<Class<? extends JavaScriptModule>> createJSModules() {
return Collections.emptyList();
}
@Override
public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
return Collections.emptyList();
}
}
| [
"[email protected]"
] | |
0da36c740cafe5ae32126e5ad841487dc7b806a7 | 7fa9c6b0fa1d0726ae1cda0199716c811a1ea01b | /Crawler/data/LatexAnnotatedTextBuilder.java | 55f50d9890b485fb5f13a15522448a987b5d4b80 | [] | no_license | NayrozD/DD2476-Project | b0ca75799793d8ced8d4d3ba3c43c79bb84a72c0 | 94dfb3c0a470527b069e2e0fd9ee375787ee5532 | refs/heads/master | 2023-03-18T04:04:59.111664 | 2021-03-10T15:03:07 | 2021-03-10T15:03:07 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 42,849 | java | 3
https://raw.githubusercontent.com/valentjn/ltex-ls-old/master/src/main/java/org/bsplines/languagetool_languageserver/latex/LatexAnnotatedTextBuilder.java
package org.bsplines.languagetool_languageserver.latex;
import org.apache.commons.text.StringEscapeUtils;
import org.bsplines.languagetool_languageserver.Tools;
import org.languagetool.markup.AnnotatedText;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.regex.*;
public class LatexAnnotatedTextBuilder {
private enum Mode {
PARAGRAPH_TEXT,
INLINE_TEXT,
HEADING,
INLINE_MATH,
DISPLAY_MATH,
IGNORE_ENVIRONMENT,
RSWEAVE,
}
private static final LatexCommandSignature[] defaultCommandSignatures = {
new LatexCommandSignature("\\addbibresource{}"),
new LatexCommandSignature("\\addtocontents{}"),
new LatexCommandSignature("\\addtocounter{}{}"),
new LatexCommandSignature("\\addtokomafont{}{}"),
new LatexCommandSignature("\\addtotheorempostheadhook{}"),
new LatexCommandSignature("\\addxcontentsline{}{}{}"),
new LatexCommandSignature("\\algdef{}[]{}{}"),
new LatexCommandSignature("\\algnewcommand{}{}"),
new LatexCommandSignature("\\algrenewcommand{}{}"),
new LatexCommandSignature("\\arabic{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\AtBeginEnvironment{}{}"),
new LatexCommandSignature("\\AtEndEnvironment{}{}"),
new LatexCommandSignature("\\autopageref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\autopageref*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\autoref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\autoref*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\bibitem{}"),
new LatexCommandSignature("\\bibliography{}"),
new LatexCommandSignature("\\bibliographystyle{}"),
new LatexCommandSignature("\\captionof{}"),
new LatexCommandSignature("\\captionsetup{}"),
new LatexCommandSignature("\\captionsetup[]{}"),
new LatexCommandSignature("\\cite{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\cite[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\cite*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\cite*[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealp{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealp[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealp*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealp*[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealt{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealt[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealt*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citealt*[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citep{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citep[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citep*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citep*[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citet{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citet[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citet*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\citet*[]{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\clearfield{}"),
new LatexCommandSignature("\\cref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\Cref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\crefname{}{}{}"),
new LatexCommandSignature("\\Crefname{}{}{}"),
new LatexCommandSignature("\\DeclareCaptionFormat{}{}"),
new LatexCommandSignature("\\DeclareCaptionLabelFormat{}{}"),
new LatexCommandSignature("\\DeclareCiteCommand{}{}{}{}{}"),
new LatexCommandSignature("\\DeclareCiteCommand{}[]{}{}{}{}"),
new LatexCommandSignature("\\DeclareFieldFormat{}{}"),
new LatexCommandSignature("\\DeclareFieldFormat[]{}{}"),
new LatexCommandSignature("\\DeclareGraphicsExtensions{}"),
new LatexCommandSignature("\\DeclareMathAlphabet{}{}{}{}{}"),
new LatexCommandSignature("\\DeclareMathOperator{}{}"),
new LatexCommandSignature("\\DeclareMathOperator*{}{}"),
new LatexCommandSignature("\\DeclareNameAlias{}{}"),
new LatexCommandSignature("\\DeclareNewTOC{}"),
new LatexCommandSignature("\\DeclareNewTOC[]{}"),
new LatexCommandSignature("\\declaretheorem{}"),
new LatexCommandSignature("\\declaretheorem[]{}"),
new LatexCommandSignature("\\declaretheoremstyle{}"),
new LatexCommandSignature("\\declaretheoremstyle[]{}"),
new LatexCommandSignature("\\DeclareTOCStyleEntry{}"),
new LatexCommandSignature("\\DeclareTOCStyleEntry[]{}{}"),
new LatexCommandSignature("\\defbibheading{}{}"),
new LatexCommandSignature("\\defbibheading{}[]{}"),
new LatexCommandSignature("\\defbibnote{}{}"),
new LatexCommandSignature("\\definecolor{}{}{}"),
new LatexCommandSignature("\\DisableLigatures{}"),
new LatexCommandSignature("\\documentclass{}"),
new LatexCommandSignature("\\documentclass[]{}"),
new LatexCommandSignature("\\email{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\eqref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\etocsetnexttocdepth{}"),
new LatexCommandSignature("\\etocsettocstyle{}{}"),
new LatexCommandSignature("\\floatname{}{}"),
new LatexCommandSignature("\\floatstyle{}"),
new LatexCommandSignature("\\foreignlanguage{}{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\GenericWarning{}{}"),
new LatexCommandSignature("\\geometry{}"),
new LatexCommandSignature("\\glsaddstoragekey{}{}{}"),
new LatexCommandSignature("\\graphicspath{}"),
new LatexCommandSignature("\\href{}{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\hyperref[]"),
new LatexCommandSignature("\\hypersetup{}"),
new LatexCommandSignature("\\ifcurrentfield{}"),
new LatexCommandSignature("\\ifentrytype{}"),
new LatexCommandSignature("\\iftoggle{}"),
new LatexCommandSignature("\\include{}"),
new LatexCommandSignature("\\includegraphics{}"),
new LatexCommandSignature("\\includegraphics[]{}"),
new LatexCommandSignature("\\includepdf{}"),
new LatexCommandSignature("\\includepdf[]{}"),
new LatexCommandSignature("\\input{}"),
new LatexCommandSignature("\\KOMAoptions{}"),
new LatexCommandSignature("\\KOMAScript", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\label{}"),
new LatexCommandSignature("\\LaTeX", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\lettrine{}{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\lettrine[]{}{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\linespread{}"),
new LatexCommandSignature("\\luadirect{}"),
new LatexCommandSignature("\\luaexec{}"),
new LatexCommandSignature("\\mdfdefinestyle{}{}"),
new LatexCommandSignature("\\multicolumn{}{}"),
new LatexCommandSignature("\\multirow{}{}"),
new LatexCommandSignature("\\newboolean{}"),
new LatexCommandSignature("\\newcolumntype{}{}"),
new LatexCommandSignature("\\newcommand{}{}"),
new LatexCommandSignature("\\newcommand{}[]{}"),
new LatexCommandSignature("\\newcommand*{}{}"),
new LatexCommandSignature("\\newcommand*{}[]{}"),
new LatexCommandSignature("\\newcounter{}"),
new LatexCommandSignature("\\newenvironment{}{}{}"),
new LatexCommandSignature("\\newenvironment{}[]{}{}"),
new LatexCommandSignature("\\newenvironment*{}{}{}"),
new LatexCommandSignature("\\newenvironment*{}[]{}{}"),
new LatexCommandSignature("\\newfloat{}{}{}"),
new LatexCommandSignature("\\newfloat{}{}{}[]"),
new LatexCommandSignature("\\newgeometry{}"),
new LatexCommandSignature("\\newglossaryentry{}{}"),
new LatexCommandSignature("\\newglossarystyle{}{}"),
new LatexCommandSignature("\\newtheorem{}{}"),
new LatexCommandSignature("\\newtheorem*{}{}"),
new LatexCommandSignature("\\newtoggle{}"),
new LatexCommandSignature("\\nolinkurl{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\PackageWarning{}{}"),
new LatexCommandSignature("\\pagenumbering{}"),
new LatexCommandSignature("\\pageref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\pageref*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\pagestyle{}"),
new LatexCommandSignature("\\pdfbookmark{}{}"),
new LatexCommandSignature("\\pdfbookmark[]{}{}"),
new LatexCommandSignature("\\pgfdeclaredecoration{}{}{}"),
new LatexCommandSignature("\\pgfmathsetseed{}"),
new LatexCommandSignature("\\printbibliography[]"),
new LatexCommandSignature("\\printglossary[]"),
new LatexCommandSignature("\\providecommand{}{}"),
new LatexCommandSignature("\\providecommand{}[]{}"),
new LatexCommandSignature("\\providecommand*{}{}"),
new LatexCommandSignature("\\providecommand*{}[]{}"),
new LatexCommandSignature("\\raisebox{}"),
new LatexCommandSignature("\\RedeclareSectionCommand{}"),
new LatexCommandSignature("\\RedeclareSectionCommand[]{}"),
new LatexCommandSignature("\\RedeclareSectionCommands{}"),
new LatexCommandSignature("\\RedeclareSectionCommands[]{}"),
new LatexCommandSignature("\\ref{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\ref*{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\renewbibmacro{}{}"),
new LatexCommandSignature("\\renewbibmacro*{}{}"),
new LatexCommandSignature("\\renewcommand{}{}"),
new LatexCommandSignature("\\renewcommand{}[]{}"),
new LatexCommandSignature("\\renewcommand*{}{}"),
new LatexCommandSignature("\\renewcommand*{}[]{}"),
new LatexCommandSignature("\\renewenvironment{}{}{}"),
new LatexCommandSignature("\\renewenvironment{}[]{}{}"),
new LatexCommandSignature("\\renewenvironment*{}{}{}"),
new LatexCommandSignature("\\renewenvironment*{}[]{}{}"),
new LatexCommandSignature("\\RequirePackage{}"),
new LatexCommandSignature("\\scalebox{}"),
new LatexCommandSignature("\\setboolean{}"),
new LatexCommandSignature("\\setcopyright{}"),
new LatexCommandSignature("\\setcounter{}{}"),
new LatexCommandSignature("\\setenumerate{}"),
new LatexCommandSignature("\\setglossarystyle{}"),
new LatexCommandSignature("\\setitemize{}"),
new LatexCommandSignature("\\setkomafont{}{}"),
new LatexCommandSignature("\\setkomavar{}{}"),
new LatexCommandSignature("\\setkomavar{}[]{}"),
new LatexCommandSignature("\\setkomavar*{}{}"),
new LatexCommandSignature("\\setkomavar*{}[]{}"),
new LatexCommandSignature("\\setlength{}{}"),
new LatexCommandSignature("\\setlist{}"),
new LatexCommandSignature("\\SetMathAlphabet{}{}{}{}{}{}"),
new LatexCommandSignature("\\@setplength{}{}"),
new LatexCommandSignature("\\setstretch{}"),
new LatexCommandSignature("\\sisetup{}"),
new LatexCommandSignature("\\stepcounter{}"),
new LatexCommandSignature("\\SweaveInput{}"),
new LatexCommandSignature("\\SweaveOpts{}"),
new LatexCommandSignature("\\SweaveSyntax{}"),
new LatexCommandSignature("\\TeX", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\textcolor{}"),
new LatexCommandSignature("\\textproc{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\thispagestyle{}"),
new LatexCommandSignature("\\tikz{}"),
new LatexCommandSignature("\\tikzset{}"),
new LatexCommandSignature("\\todo{}"),
new LatexCommandSignature("\\todo[]{}"),
new LatexCommandSignature("\\togglefalse{}"),
new LatexCommandSignature("\\toggletrue{}"),
new LatexCommandSignature("\\url{}", LatexCommandSignature.Action.DUMMY),
new LatexCommandSignature("\\usebibmacro{}"),
new LatexCommandSignature("\\usekomafont{}"),
new LatexCommandSignature("\\usepackage{}"),
new LatexCommandSignature("\\usepackage[]{}"),
new LatexCommandSignature("\\usetikzlibrary{}"),
new LatexCommandSignature("\\value{}"),
new LatexCommandSignature("\\vspace{}"),
new LatexCommandSignature("\\vspace*{}"),
new LatexCommandSignature("\\WarningFilter{}{}"),
};
private static final String[] defaultIgnoreEnvironments = {
"lstlisting", "tikzpicture", "verbatim",
};
private static final Pattern commandPattern = Pattern.compile(
"^\\\\(([^A-Za-z@]|([A-Za-z@]+))\\*?)");
private static final Pattern argumentPattern = Pattern.compile("^\\{[^\\}]*?\\}");
private static final Pattern commentPattern = Pattern.compile(
"^%.*?($|((\n|\r|\r\n)[ \n\r\t]*))");
private static final Pattern whiteSpacePattern = Pattern.compile(
"^[ \n\r\t]+(%.*?($|((\n|\r|\r\n)[ \n\r\t]*)))?");
private static final Pattern lengthPattern = Pattern.compile(
"-?[0-9]*(\\.[0-9]+)?(pt|mm|cm|ex|em|bp|dd|pc|in)");
private static final Pattern lengthInBracePattern = Pattern.compile(
"^\\{" + lengthPattern.pattern() + "\\}");
private static final Pattern lengthInBracketPattern = Pattern.compile(
"^\\[" + lengthPattern.pattern() + "\\]");
private static final Pattern emDashPattern = Pattern.compile("^---");
private static final Pattern enDashPattern = Pattern.compile("^--");
private static final Pattern accentPattern1 = Pattern.compile(
"^(\\\\[`'\\^~\"=\\.])(([A-Za-z]|\\\\i)|(\\{([A-Za-z]|\\\\i)\\}))");
private static final Pattern accentPattern2 = Pattern.compile(
"^(\\\\[cr])( *([A-Za-z])|\\{([A-Za-z])\\})");
private static final Pattern displayMathPattern = Pattern.compile("^\\$\\$");
private static final Pattern verbCommandPattern = Pattern.compile("^\\\\verb\\*?(.).*?\\1");
private static final Pattern rsweaveBeginPattern = Pattern.compile("^<<.*?>>=");
private static final Pattern rsweaveEndPattern = Pattern.compile("^@");
private static final String[] mathEnvironments = {"align", "align*", "alignat", "alignat*",
"displaymath", "eqnarray", "eqnarray*", "equation", "equation*", "flalign", "flalign*",
"gather", "gather*", "math", "multline", "multline*"};
private org.languagetool.markup.AnnotatedTextBuilder builder =
new org.languagetool.markup.AnnotatedTextBuilder();
private String text;
private int pos;
private int dummyCounter;
private String lastSpace;
private String lastPunctuation;
private String dummyLastSpace;
private String dummyLastPunctuation;
private boolean isMathEmpty;
private boolean preserveDummyLast;
private boolean canInsertSpaceBeforeDummy;
private boolean isMathCharTrivial;
private Stack<Mode> modeStack;
private char curChar;
private String curString;
private Mode curMode;
public String language = "en-US";
public String codeLanguageId = "latex";
public List<LatexCommandSignature> commandSignatures =
new ArrayList<>(Arrays.asList(defaultCommandSignatures));
public List<String> ignoreEnvironments =
new ArrayList<>(Arrays.asList(defaultIgnoreEnvironments));
public boolean isInStrictMode = false;
private String matchFromPosition(Pattern pattern) {
return matchFromPosition(pattern, pos);
}
private String matchFromPosition(Pattern pattern, int pos) {
Matcher matcher = pattern.matcher(text.substring(pos));
return (matcher.find() ? matcher.group() : "");
}
private String generateDummy() {
String dummy;
if (isTextMode(curMode)) {
dummy = Tools.generateDummy(language, dummyCounter++);
} else if (isMathEmpty) {
if (curMode == Mode.DISPLAY_MATH) {
dummy = (lastSpace.isEmpty() ? " " : "");
} else {
dummy = "";
}
} else if (curMode == Mode.DISPLAY_MATH) {
dummy = ((lastSpace.isEmpty() ? " " : "")) + Tools.generateDummy(language, dummyCounter++) +
dummyLastPunctuation + ((modeStack.peek() == Mode.INLINE_TEXT) ? dummyLastSpace : " ");
} else {
dummy = Tools.generateDummy(language, dummyCounter++) + dummyLastPunctuation + dummyLastSpace;
}
dummyLastSpace = "";
dummyLastPunctuation = "";
return dummy;
}
private LatexAnnotatedTextBuilder addText(String text) {
if (text.isEmpty()) return this;
builder.addText(text);
pos += text.length();
textAdded(text);
return this;
}
private LatexAnnotatedTextBuilder addMarkup(String markup) {
if (markup.isEmpty()) return this;
builder.addMarkup(markup);
pos += markup.length();
if (preserveDummyLast) {
preserveDummyLast = false;
} else {
dummyLastSpace = "";
dummyLastPunctuation = "";
}
return this;
}
private LatexAnnotatedTextBuilder addMarkup(String markup, String interpretAs)
throws InterruptedException {
if (interpretAs.isEmpty()) {
return addMarkup(markup);
} else {
builder.addMarkup(markup, interpretAs);
pos += markup.length();
preserveDummyLast = false;
textAdded(interpretAs);
return this;
}
}
private void textAdded(String text) {
if (text.isEmpty()) return;
char lastChar = text.charAt(text.length() - 1);
lastSpace = (((lastChar == ' ') || (lastChar == '\n') || (lastChar == '\r')) ? " " : "");
lastPunctuation = (isPunctuation(lastChar) ? " " : "");
}
private void popMode() {
modeStack.pop();
if (modeStack.isEmpty()) modeStack.push(Mode.PARAGRAPH_TEXT);
}
private static boolean isPunctuation(char ch) {
return ((ch == '.') || (ch == ',') || (ch == ':') || (ch == ';'));
}
private static boolean isMathMode(Mode mode) {
return ((mode == Mode.INLINE_MATH) || (mode == Mode.DISPLAY_MATH));
}
private static boolean isIgnoreEnvironmentMode(Mode mode) {
return (mode == Mode.IGNORE_ENVIRONMENT);
}
private static boolean isRsweaveMode(Mode mode) {
return (mode == Mode.RSWEAVE);
}
private static boolean isTextMode(Mode mode) {
return !isMathMode(mode) && !isIgnoreEnvironmentMode(mode);
}
private void enterDisplayMath() {
modeStack.push(Mode.DISPLAY_MATH);
isMathEmpty = true;
canInsertSpaceBeforeDummy = true;
}
private void enterInlineMath() {
modeStack.push(Mode.INLINE_MATH);
isMathEmpty = true;
canInsertSpaceBeforeDummy = true;
isMathCharTrivial = true;
}
private String getDebugInformation(String text) {
String remainingText = StringEscapeUtils.escapeJava(
text.substring(pos, Math.min(pos + 100, text.length())));
return "Remaining text = \"" + remainingText +
"\", pos = " + pos + ", dummyCounter = " + dummyCounter + ", lastSpace = \"" + lastSpace +
"\", lastPunctuation = \"" + lastPunctuation + "\", dummyLastSpace = \"" + dummyLastSpace +
"\", dummyLastPunctuation = \"" + dummyLastPunctuation +
"\", isMathEmpty = " + isMathEmpty + ", preserveDummyLast = " + preserveDummyLast +
", canInsertSpaceBeforeDummy = " + canInsertSpaceBeforeDummy +
", isMathCharTrivial = " + isMathCharTrivial + ", modeStack = " + modeStack +
", curChar = \"" + curChar + "\", curString = \"" + curString + "\", curMode = " + curMode;
}
private static boolean containsTwoEndsOfLine(String text) {
return (text.contains("\n\n") || text.contains("\r\r") || text.contains("\r\n\r\n"));
}
public LatexAnnotatedTextBuilder addCode(String text) throws InterruptedException {
this.text = text;
pos = 0;
dummyCounter = 0;
lastSpace = "";
lastPunctuation = "";
dummyLastSpace = "";
dummyLastPunctuation = "";
isMathEmpty = true;
preserveDummyLast = false;
canInsertSpaceBeforeDummy = false;
isMathCharTrivial = false;
modeStack = new Stack<>();
modeStack.push(Mode.PARAGRAPH_TEXT);
Pattern ignoreEnvironmentEndPattern = null;
int lastPos = -1;
while (pos < text.length()) {
if (Thread.currentThread().isInterrupted()) throw new InterruptedException();
curChar = text.charAt(pos);
curString = String.valueOf(curChar);
curMode = modeStack.peek();
isMathCharTrivial = false;
lastPos = pos;
if (isIgnoreEnvironmentMode(curMode)) {
String ignoreEnvironmentEnd = matchFromPosition(ignoreEnvironmentEndPattern);
if (ignoreEnvironmentEnd.isEmpty()) {
addMarkup(curString);
} else {
popMode();
addMarkup(ignoreEnvironmentEnd);
}
} else if (codeLanguageId.equals("rsweave") && isRsweaveMode(curMode)) {
String rsweaveEnd = matchFromPosition(rsweaveEndPattern);
if (rsweaveEnd.isEmpty()) {
addMarkup(curString);
} else {
popMode();
addMarkup(rsweaveEnd);
}
} else {
switch (curChar) {
case '\\': {
String command = matchFromPosition(commandPattern);
if (command.equals("\\begin") || command.equals("\\end")) {
preserveDummyLast = true;
addMarkup(command);
String argument = matchFromPosition(argumentPattern);
String environmentName = argument.substring(1, argument.length() - 1);
String interpretAs = "";
if (Arrays.asList(mathEnvironments).contains(environmentName)) {
if (command.equals("\\begin")) {
if (environmentName.equals("math")) {
enterInlineMath();
} else {
enterDisplayMath();
}
} else {
popMode();
interpretAs = generateDummy();
}
} else if (command.equals("\\begin") &&
ignoreEnvironments.contains(environmentName)) {
modeStack.push(Mode.IGNORE_ENVIRONMENT);
ignoreEnvironmentEndPattern = Pattern.compile(
"^\\\\end\\{" + Pattern.quote(environmentName) + "\\}");
} else {
if (command.equals("\\begin")) modeStack.push(curMode);
else popMode();
}
if (!isIgnoreEnvironmentMode(modeStack.peek())) {
isMathCharTrivial = true;
preserveDummyLast = true;
addMarkup(argument, interpretAs);
if (command.equals("\\begin")) {
while (pos < text.length()) {
if (Thread.currentThread().isInterrupted()) throw new InterruptedException();
String environmentArgument = LatexCommandSignature.matchArgumentFromPosition(
text, pos, LatexCommandSignature.ArgumentType.BRACE);
if (!environmentArgument.isEmpty()) {
addMarkup(environmentArgument);
} else {
environmentArgument = LatexCommandSignature.matchArgumentFromPosition(
text, pos, LatexCommandSignature.ArgumentType.BRACKET);
if (!environmentArgument.isEmpty()) {
addMarkup(environmentArgument);
} else {
break;
}
}
}
}
}
} else if (command.equals("\\$") || command.equals("\\%") || command.equals("\\&")) {
addMarkup(command, command.substring(1));
} else if (command.equals("\\[") || command.equals("\\]") ||
command.equals("\\(") || command.equals("\\)")) {
if (command.equals("\\[")) {
enterDisplayMath();
addMarkup(command);
} else if (command.equals("\\(")) {
enterInlineMath();
addMarkup(command);
} else {
popMode();
addMarkup(command, generateDummy());
}
} else if (command.equals("\\AA")) {
addMarkup(command, "\u00c5");
} else if (command.equals("\\O")) {
addMarkup(command, "\u00d8");
} else if (command.equals("\\aa")) {
addMarkup(command, "\u00e5");
} else if (command.equals("\\ss")) {
addMarkup(command, "\u00df");
} else if (command.equals("\\o")) {
addMarkup(command, "\u00f8");
} else if (command.equals("\\`") || command.equals("\\'") || command.equals("\\^") ||
command.equals("\\~") || command.equals("\\\"") || command.equals("\\=") ||
command.equals("\\.")) {
Matcher matcher = accentPattern1.matcher(text.substring(pos));
if (matcher.find()) {
String accentCommand = matcher.group(1);
String letter = ((matcher.group(3) != null) ? matcher.group(3) : matcher.group(5));
String interpretAs = "";
switch (accentCommand.charAt(1)) {
case '`': {
if (letter.equals("A")) interpretAs = "\u00c0";
else if (letter.equals("E")) interpretAs = "\u00c8";
else if (letter.equals("I")) interpretAs = "\u00cc";
else if (letter.equals("O")) interpretAs = "\u00d2";
else if (letter.equals("U")) interpretAs = "\u00d9";
else if (letter.equals("a")) interpretAs = "\u00e0";
else if (letter.equals("e")) interpretAs = "\u00e8";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u00ec";
else if (letter.equals("o")) interpretAs = "\u00f2";
else if (letter.equals("u")) interpretAs = "\u00f9";
break;
}
case '\'': {
if (letter.equals("A")) interpretAs = "\u00c1";
else if (letter.equals("E")) interpretAs = "\u00c9";
else if (letter.equals("I")) interpretAs = "\u00cd";
else if (letter.equals("O")) interpretAs = "\u00d3";
else if (letter.equals("U")) interpretAs = "\u00da";
else if (letter.equals("Y")) interpretAs = "\u00dd";
else if (letter.equals("a")) interpretAs = "\u00e1";
else if (letter.equals("e")) interpretAs = "\u00e9";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u00ed";
else if (letter.equals("o")) interpretAs = "\u00f3";
else if (letter.equals("u")) interpretAs = "\u00fa";
else if (letter.equals("y")) interpretAs = "\u00fd";
break;
}
case '^': {
if (letter.equals("A")) interpretAs = "\u00c2";
else if (letter.equals("E")) interpretAs = "\u00ca";
else if (letter.equals("I")) interpretAs = "\u00ce";
else if (letter.equals("O")) interpretAs = "\u00d4";
else if (letter.equals("U")) interpretAs = "\u00db";
else if (letter.equals("Y")) interpretAs = "\u0176";
else if (letter.equals("a")) interpretAs = "\u00e2";
else if (letter.equals("e")) interpretAs = "\u00ea";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u00ee";
else if (letter.equals("o")) interpretAs = "\u00f4";
else if (letter.equals("u")) interpretAs = "\u00fb";
else if (letter.equals("y")) interpretAs = "\u0177";
break;
}
case '~': {
if (letter.equals("A")) interpretAs = "\u00c3";
else if (letter.equals("E")) interpretAs = "\u1ebc";
else if (letter.equals("I")) interpretAs = "\u0128";
else if (letter.equals("N")) interpretAs = "\u00d1";
else if (letter.equals("O")) interpretAs = "\u00d5";
else if (letter.equals("U")) interpretAs = "\u0168";
else if (letter.equals("a")) interpretAs = "\u00e3";
else if (letter.equals("e")) interpretAs = "\u1ebd";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u0129";
else if (letter.equals("n")) interpretAs = "\u00f1";
else if (letter.equals("o")) interpretAs = "\u00f5";
else if (letter.equals("u")) interpretAs = "\u0169";
break;
}
case '"': {
if (letter.equals("A")) interpretAs = "\u00c4";
else if (letter.equals("E")) interpretAs = "\u00cb";
else if (letter.equals("I")) interpretAs = "\u00cf";
else if (letter.equals("O")) interpretAs = "\u00d6";
else if (letter.equals("U")) interpretAs = "\u00dc";
else if (letter.equals("Y")) interpretAs = "\u0178";
else if (letter.equals("a")) interpretAs = "\u00e4";
else if (letter.equals("e")) interpretAs = "\u00eb";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u00ef";
else if (letter.equals("o")) interpretAs = "\u00f6";
else if (letter.equals("u")) interpretAs = "\u00fc";
else if (letter.equals("y")) interpretAs = "\u00ff";
break;
}
case '=': {
if (letter.equals("A")) interpretAs = "\u0100";
else if (letter.equals("E")) interpretAs = "\u0112";
else if (letter.equals("I")) interpretAs = "\u012a";
else if (letter.equals("O")) interpretAs = "\u014c";
else if (letter.equals("U")) interpretAs = "\u016a";
else if (letter.equals("Y")) interpretAs = "\u0232";
else if (letter.equals("a")) interpretAs = "\u0101";
else if (letter.equals("e")) interpretAs = "\u0113";
else if (letter.equals("i") || letter.equals("\\i")) interpretAs = "\u012b";
else if (letter.equals("o")) interpretAs = "\u014d";
else if (letter.equals("u")) interpretAs = "\u016b";
else if (letter.equals("y")) interpretAs = "\u0233";
break;
}
case '.': {
if (letter.equals("A")) interpretAs = "\u0226";
else if (letter.equals("E")) interpretAs = "\u0116";
else if (letter.equals("I")) interpretAs = "\u0130";
else if (letter.equals("O")) interpretAs = "\u022e";
else if (letter.equals("a")) interpretAs = "\u0227";
else if (letter.equals("e")) interpretAs = "\u0117";
else if (letter.equals("o")) interpretAs = "\u022f";
break;
}
}
addMarkup(matcher.group(), interpretAs);
} else {
addMarkup(command);
}
} else if (command.equals("\\c") || command.equals("\\r")) {
Matcher matcher = accentPattern2.matcher(text.substring(pos));
if (matcher.find()) {
String accentCommand = matcher.group(1);
String letter = ((matcher.group(3) != null) ? matcher.group(3) : matcher.group(4));
String interpretAs = "";
switch (accentCommand.charAt(1)) {
case 'c': {
if (letter.equals("C")) interpretAs = "\u00c7";
else if (letter.equals("c")) interpretAs = "\u00e7";
break;
}
case 'r': {
if (letter.equals("A")) interpretAs = "\u00c5";
else if (letter.equals("U")) interpretAs = "\u016e";
else if (letter.equals("a")) interpretAs = "\u00e5";
else if (letter.equals("u")) interpretAs = "\u016f";
break;
}
}
addMarkup(matcher.group(), interpretAs);
} else {
addMarkup(command);
}
} else if (command.equals("\\-")) {
addMarkup(command);
} else if (command.equals("\\ ") || command.equals("\\,") || command.equals("\\;") ||
command.equals("\\\\") || command.equals("\\hfill") || command.equals("\\hspace") ||
command.equals("\\hspace*") || command.equals("\\quad") ||
command.equals("\\qquad") || command.equals("\\newline")) {
if (command.equals("\\hspace") || command.equals("\\hspace*")) {
String argument = matchFromPosition(argumentPattern, pos + command.length());
command += argument;
}
if (isMathMode(curMode) && lastSpace.isEmpty() && canInsertSpaceBeforeDummy) {
addMarkup(command, " ");
} else {
preserveDummyLast = true;
if (isMathMode(curMode)) {
addMarkup(command);
dummyLastSpace = " ";
} else {
String space = " ";
if (!lastSpace.isEmpty()) {
space = "";
} else if (command.equals("\\,")) {
space = "\u202f";
}
addMarkup(command, space);
}
}
} else if (command.equals("\\dots")) {
String interpretAs = (isMathMode(curMode) ? "" : "...");
addMarkup(command, interpretAs);
} else if (command.equals("\\euro")) {
addMarkup(command, "\u20ac");
} else if (command.equals("\\footnote")) {
modeStack.push(Mode.INLINE_TEXT);
String interpretAs = (isMathMode(curMode) ? generateDummy() :
(lastSpace.isEmpty() ? " " : ""));
addMarkup(command + "{", interpretAs);
} else if (command.equals("\\notag") || command.equals("\\qed")) {
preserveDummyLast = true;
addMarkup(command);
} else if (command.equals("\\part") || command.equals("\\chapter") ||
command.equals("\\section") || command.equals("\\subsection") ||
command.equals("\\subsubsection") || command.equals("\\paragraph") ||
command.equals("\\subparagraph") ||
command.equals("\\part*") || command.equals("\\chapter*") ||
command.equals("\\section*") || command.equals("\\subsection*") ||
command.equals("\\subsubsection*") || command.equals("\\paragraph*") ||
command.equals("\\subparagraph*")) {
modeStack.push(Mode.HEADING);
addMarkup(command + "{");
} else if (command.equals("\\text") || command.equals("\\intertext")) {
modeStack.push(Mode.INLINE_TEXT);
String interpretAs = (isMathMode(curMode) ? generateDummy() : "");
addMarkup(command + "{", interpretAs);
} else if (command.equals("\\verb")) {
String verbCommand = matchFromPosition(verbCommandPattern);
addMarkup(verbCommand, generateDummy());
} else {
String match = "";
LatexCommandSignature matchingCommand = null;
for (LatexCommandSignature LatexCommandSignature : commandSignatures) {
if (Thread.currentThread().isInterrupted()) throw new InterruptedException();
if (LatexCommandSignature.name.equals(command)) {
String curMatch = LatexCommandSignature.matchFromPosition(text, pos);
if (curMatch.length() > match.length()) {
match = curMatch;
matchingCommand = LatexCommandSignature;
}
}
}
if (matchingCommand == null) {
addMarkup(command);
} else {
switch (matchingCommand.action) {
case IGNORE: {
addMarkup(match);
break;
}
case DUMMY: {
addMarkup(match, generateDummy());
break;
}
}
}
}
break;
}
case '{': {
String length = matchFromPosition(lengthInBracePattern);
if (!length.isEmpty()) {
addMarkup(length);
} else {
modeStack.push(curMode);
addMarkup(curString);
}
break;
}
case '}': {
String interpretAs = "";
if ((curMode == Mode.HEADING) && lastPunctuation.isEmpty()) interpretAs = ".";
popMode();
addMarkup(curString, interpretAs);
canInsertSpaceBeforeDummy = true;
if (isTextMode(curMode) && isMathMode(modeStack.peek())) isMathEmpty = true;
isMathCharTrivial = true;
break;
}
case '$': {
String displayMath = matchFromPosition(displayMathPattern);
if (!displayMath.isEmpty()) {
if (curMode == Mode.DISPLAY_MATH) {
popMode();
addMarkup(displayMath, generateDummy());
} else {
enterDisplayMath();
addMarkup(displayMath);
}
} else {
if (curMode == Mode.INLINE_MATH) {
popMode();
addMarkup(curString, generateDummy());
} else {
enterInlineMath();
addMarkup(curString);
}
}
break;
}
case '%': {
String comment = matchFromPosition(commentPattern);
preserveDummyLast = true;
isMathCharTrivial = true;
addMarkup(comment, (containsTwoEndsOfLine(comment) ? "\n\n" : ""));
break;
}
case ' ':
case '&':
case '~':
case '\n':
case '\r':
case '\t': {
String whiteSpace = (((curChar != '~') && (curChar != '&')) ?
matchFromPosition(whiteSpacePattern) : curString);
preserveDummyLast = true;
isMathCharTrivial = true;
if (isTextMode(curMode)) {
if (containsTwoEndsOfLine(whiteSpace)) {
addMarkup(whiteSpace, "\n\n");
} else {
addMarkup(whiteSpace, (lastSpace.isEmpty() ? " " : ""));
}
} else {
addMarkup(whiteSpace);
}
if ((curChar == '~') || (curChar == '&')) {
dummyLastSpace = " ";
}
break;
}
case '`':
case '\'':
case '"': {
if (isTextMode(curMode)) {
String quote = "";
String smartQuote = "";
if (pos + 1 < text.length()) {
quote = text.substring(pos, pos + 2);
if (quote.equals("``") || quote.equals("\"'")) {
smartQuote = "\u201c";
} else if (quote.equals("''")) {
smartQuote = "\u201d";
} else if (quote.equals("\"`")) {
smartQuote = "\u201e";
} else {
quote = "";
}
}
if (quote.isEmpty()) addText(curString);
else addMarkup(quote, smartQuote);
} else {
addMarkup(curString);
}
break;
}
case '-': {
String emDash = matchFromPosition(emDashPattern);
if (isTextMode(curMode)) {
if (!emDash.isEmpty()) {
addMarkup(emDash, "\u2014");
break;
} else {
String enDash = matchFromPosition(enDashPattern);
if (!enDash.isEmpty()) {
addMarkup(enDash, "\u2013");
break;
}
}
}
}
case '[': {
String length = matchFromPosition(lengthInBracketPattern);
if (!length.isEmpty()) {
isMathCharTrivial = true;
preserveDummyLast = true;
addMarkup(length);
break;
}
}
case '<': {
if (codeLanguageId.equals("rsweave")) {
String rsweaveBegin = matchFromPosition(rsweaveBeginPattern);
if (!rsweaveBegin.isEmpty()) {
modeStack.push(Mode.RSWEAVE);
addMarkup(rsweaveBegin);
break;
}
}
}
default: {
if (isTextMode(curMode)) {
addText(curString);
if (isPunctuation(curChar)) lastPunctuation = curString;
} else {
addMarkup(curString);
if (isPunctuation(curChar)) dummyLastPunctuation = curString;
}
break;
}
}
}
if (!isMathCharTrivial) {
canInsertSpaceBeforeDummy = false;
isMathEmpty = false;
}
if (pos == lastPos) {
if (isInStrictMode) {
throw new RuntimeException(Tools.i18n(
"latexAnnotatedTextBuilderInfiniteLoop", getDebugInformation(text)));
} else {
Tools.logger.warning(Tools.i18n(
"latexAnnotatedTextBuilderPreventedInfiniteLoop", getDebugInformation(text)));
pos++;
}
}
}
return this;
}
public AnnotatedText getAnnotatedText() {
return builder.build();
}
}
| [
"[email protected]"
] | |
6e4a11d75372665c51fbfaa02a16ca7a29aa8560 | 995f73d30450a6dce6bc7145d89344b4ad6e0622 | /P9-8.0/src/main/java/com/android/server/display/DisplayPowerState.java | 3b8f83aab0fadb0711329c1866f855aa15136f4e | [] | no_license | morningblu/HWFramework | 0ceb02cbe42585d0169d9b6c4964a41b436039f5 | 672bb34094b8780806a10ba9b1d21036fd808b8e | refs/heads/master | 2023-07-29T05:26:14.603817 | 2021-09-03T05:23:34 | 2021-09-03T05:23:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 14,264 | java | package com.android.server.display;
import android.content.Context;
import android.os.Handler;
import android.os.SystemProperties;
import android.util.FloatProperty;
import android.util.Flog;
import android.util.IntProperty;
import android.util.Log;
import android.util.Slog;
import android.view.Choreographer;
import android.view.Display;
import com.android.server.FingerprintUnlockDataCollector;
import java.io.PrintWriter;
public final class DisplayPowerState {
private static final String AOD_BACK_LIGHT_KEY = "sys.current_backlight";
public static final FloatProperty<DisplayPowerState> COLOR_FADE_LEVEL = new FloatProperty<DisplayPowerState>("electronBeamLevel") {
public void setValue(DisplayPowerState object, float value) {
object.setColorFadeLevel(value);
}
public Float get(DisplayPowerState object) {
return Float.valueOf(object.getColorFadeLevel());
}
};
private static boolean DEBUG = false;
private static boolean DEBUG_Controller = false;
private static boolean DEBUG_FPLOG = false;
private static final int DEFAULT_MAX_BRIGHTNESS = 255;
private static final int HIGH_PRECISION_MAX_BRIGHTNESS = 10000;
public static final IntProperty<DisplayPowerState> SCREEN_BRIGHTNESS = new IntProperty<DisplayPowerState>("screenBrightness") {
public void setValue(DisplayPowerState object, int value) {
object.setScreenBrightness(value);
}
public Integer get(DisplayPowerState object) {
return Integer.valueOf(object.getScreenBrightness());
}
};
private static final String TAG = "DisplayPowerState";
private static final boolean mSupportAod = "1".equals(SystemProperties.get("ro.config.support_aod", null));
private FingerprintUnlockDataCollector fpDataCollector;
private final DisplayBlanker mBlanker;
private final Choreographer mChoreographer = Choreographer.getInstance();
private Runnable mCleanListener;
private final ColorFade mColorFade;
private boolean mColorFadeDrawPending;
private final Runnable mColorFadeDrawRunnable = new Runnable() {
public void run() {
DisplayPowerState.this.mColorFadeDrawPending = false;
if (DisplayPowerState.this.mColorFadePrepared) {
DisplayPowerState.this.mColorFade.draw(DisplayPowerState.this.mColorFadeLevel);
}
DisplayPowerState.this.mColorFadeReady = true;
DisplayPowerState.this.invokeCleanListenerIfNeeded();
}
};
private float mColorFadeLevel;
private boolean mColorFadePrepared;
private boolean mColorFadeReady;
private final Handler mHandler = new Handler(true);
private final PhotonicModulator mPhotonicModulator;
private int mScreenBrightness = -1;
private boolean mScreenReady;
private int mScreenState;
private boolean mScreenUpdatePending;
private final Runnable mScreenUpdateRunnable = new Runnable() {
public void run() {
DisplayPowerState.this.mScreenUpdatePending = false;
int brightness = (DisplayPowerState.this.mScreenState == 1 || DisplayPowerState.this.mColorFadeLevel <= 0.0f) ? 0 : DisplayPowerState.this.mScreenBrightness;
if (DisplayPowerState.this.mPhotonicModulator.setState(DisplayPowerState.this.mScreenState, brightness)) {
if (DisplayPowerState.DEBUG_Controller) {
Slog.d(DisplayPowerState.TAG, "Screen ready");
}
DisplayPowerState.this.mScreenReady = true;
DisplayPowerState.this.invokeCleanListenerIfNeeded();
} else if (DisplayPowerState.DEBUG_Controller) {
Slog.d(DisplayPowerState.TAG, "Screen not ready");
}
}
};
private final class PhotonicModulator extends Thread {
private static final int INITIAL_BACKLIGHT = -1;
private static final int INITIAL_SCREEN_STATE = 1;
private int mActualBacklight = -1;
private int mActualState = 1;
private boolean mBacklightChangeInProgress;
private final Object mLock = new Object();
private int mPendingBacklight = -1;
private int mPendingState = 1;
private boolean mStateChangeInProgress;
public PhotonicModulator() {
super("PhotonicModulator");
}
public boolean setState(int state, int backlight) {
boolean z = true;
synchronized (this.mLock) {
boolean stateChanged = state != this.mPendingState;
boolean backlightChanged = backlight != this.mPendingBacklight;
if (stateChanged || backlightChanged) {
boolean z2;
if (DisplayPowerState.DEBUG_Controller) {
Slog.d(DisplayPowerState.TAG, "Requesting new screen state: state=" + Display.stateToString(state) + ", backlight=" + backlight);
}
this.mPendingState = state;
this.mPendingBacklight = backlight;
boolean changeInProgress = !this.mStateChangeInProgress ? this.mBacklightChangeInProgress : true;
if (stateChanged) {
z2 = true;
} else {
z2 = this.mStateChangeInProgress;
}
this.mStateChangeInProgress = z2;
if (!backlightChanged) {
z = this.mBacklightChangeInProgress;
}
this.mBacklightChangeInProgress = z;
if (!changeInProgress) {
this.mLock.notifyAll();
}
}
z = this.mStateChangeInProgress ^ 1;
}
return z;
}
public void dump(PrintWriter pw) {
synchronized (this.mLock) {
pw.println();
pw.println("Photonic Modulator State:");
pw.println(" mPendingState=" + Display.stateToString(this.mPendingState));
pw.println(" mPendingBacklight=" + this.mPendingBacklight);
pw.println(" mActualState=" + Display.stateToString(this.mActualState));
pw.println(" mActualBacklight=" + this.mActualBacklight);
pw.println(" mStateChangeInProgress=" + this.mStateChangeInProgress);
pw.println(" mBacklightChangeInProgress=" + this.mBacklightChangeInProgress);
}
}
public void run() {
while (true) {
synchronized (this.mLock) {
int state = this.mPendingState;
boolean stateChanged = state != this.mActualState;
int backlight = this.mPendingBacklight;
boolean backlightChanged = backlight != this.mActualBacklight;
if (!stateChanged) {
DisplayPowerState.this.postScreenUpdateThreadSafe();
this.mStateChangeInProgress = false;
}
if (!backlightChanged) {
this.mBacklightChangeInProgress = false;
}
if (stateChanged || (backlightChanged ^ 1) == 0) {
this.mActualState = state;
boolean screenOnorOff = backlight == 0 || this.mActualBacklight == 0;
this.mActualBacklight = backlight;
if (screenOnorOff) {
Flog.i(NativeResponseCode.SERVICE_FOUND, "DisplayPowerState Updating screen state: state=" + Display.stateToString(state) + ", backlight=" + backlight);
if (2 == state && backlight > 0 && DisplayPowerState.mSupportAod) {
SystemProperties.set(DisplayPowerState.AOD_BACK_LIGHT_KEY, "" + backlight);
}
}
DisplayPowerState.this.mBlanker.requestDisplayState(state, backlight);
} else {
try {
this.mLock.wait();
} catch (InterruptedException e) {
}
}
}
}
}
}
static {
boolean z;
boolean z2 = true;
if (Log.HWINFO) {
z = true;
} else if (Log.HWModuleLog) {
z = Log.isLoggable(TAG, 4);
} else {
z = false;
}
DEBUG = z;
if (Log.HWLog) {
z = true;
} else if (Log.HWModuleLog) {
z = Log.isLoggable(TAG, 3);
} else {
z = false;
}
DEBUG_Controller = z;
if (!DEBUG) {
z2 = false;
}
DEBUG_FPLOG = z2;
}
public DisplayPowerState(DisplayBlanker blanker, ColorFade colorFade) {
this.mBlanker = blanker;
this.mColorFade = colorFade;
this.mPhotonicModulator = new PhotonicModulator();
this.mPhotonicModulator.start();
initialize(null);
}
public DisplayPowerState(Context context, DisplayBlanker blanker, ColorFade colorFade) {
this.mBlanker = blanker;
this.mColorFade = colorFade;
this.mPhotonicModulator = new PhotonicModulator();
this.mPhotonicModulator.start();
initialize(context);
}
private void initialize(Context context) {
this.mScreenState = 2;
if (DEBUG) {
Slog.i(TAG, ",init mScreenBrightness=" + this.mScreenBrightness);
}
scheduleScreenUpdate();
this.mColorFadePrepared = false;
this.mColorFadeLevel = 1.0f;
this.mColorFadeReady = true;
this.fpDataCollector = FingerprintUnlockDataCollector.getInstance();
}
public void setScreenState(int state) {
if (this.mScreenState != state) {
Flog.i(NativeResponseCode.SERVICE_FOUND, "DisplayPowerStatesetScreenState: state=" + state);
this.mScreenState = state;
this.mScreenReady = false;
if (DEBUG_FPLOG) {
String stateStr = Display.stateToString(state);
if (this.fpDataCollector != null) {
this.fpDataCollector.reportScreenStateOn(stateStr);
}
}
scheduleScreenUpdate();
}
}
public int getScreenState() {
return this.mScreenState;
}
public void setScreenBrightness(int brightness) {
if (this.mScreenBrightness != brightness) {
if (DEBUG && DEBUG_Controller) {
Slog.d(TAG, "setScreenBrightness: brightness=" + brightness);
}
this.mScreenBrightness = brightness;
if (this.mScreenState != 1) {
this.mScreenReady = false;
scheduleScreenUpdate();
}
}
}
public int getScreenBrightness() {
return this.mScreenBrightness;
}
public boolean prepareColorFade(Context context, int mode) {
if (this.mColorFade.prepare(context, mode)) {
this.mColorFadePrepared = true;
this.mColorFadeReady = false;
scheduleColorFadeDraw();
return true;
}
this.mColorFadePrepared = false;
this.mColorFadeReady = true;
return false;
}
public void dismissColorFade() {
this.mColorFade.dismiss();
this.mColorFadePrepared = false;
this.mColorFadeReady = true;
}
public void dismissColorFadeResources() {
this.mColorFade.dismissResources();
}
public void setColorFadeLevel(float level) {
if (this.mColorFadeLevel != level) {
Flog.i(NativeResponseCode.SERVICE_FOUND, "DisplayPowerStatesetColorFadeLevel: level=" + level);
this.mColorFadeLevel = level;
if (this.mScreenState != 1) {
this.mScreenReady = false;
scheduleScreenUpdate();
}
if (this.mColorFadePrepared) {
this.mColorFadeReady = false;
scheduleColorFadeDraw();
}
}
}
public float getColorFadeLevel() {
return this.mColorFadeLevel;
}
public boolean waitUntilClean(Runnable listener) {
if (this.mScreenReady && (this.mColorFadeReady ^ 1) == 0) {
this.mCleanListener = null;
return true;
}
this.mCleanListener = listener;
return false;
}
public void dump(PrintWriter pw) {
pw.println();
pw.println("Display Power State:");
pw.println(" mScreenState=" + Display.stateToString(this.mScreenState));
pw.println(" mScreenBrightness=" + this.mScreenBrightness);
pw.println(" mScreenReady=" + this.mScreenReady);
pw.println(" mScreenUpdatePending=" + this.mScreenUpdatePending);
pw.println(" mColorFadePrepared=" + this.mColorFadePrepared);
pw.println(" mColorFadeLevel=" + this.mColorFadeLevel);
pw.println(" mColorFadeReady=" + this.mColorFadeReady);
pw.println(" mColorFadeDrawPending=" + this.mColorFadeDrawPending);
this.mPhotonicModulator.dump(pw);
this.mColorFade.dump(pw);
}
private void scheduleScreenUpdate() {
if (!this.mScreenUpdatePending) {
this.mScreenUpdatePending = true;
postScreenUpdateThreadSafe();
}
}
private void postScreenUpdateThreadSafe() {
this.mHandler.removeCallbacks(this.mScreenUpdateRunnable);
this.mHandler.post(this.mScreenUpdateRunnable);
}
private void scheduleColorFadeDraw() {
if (!this.mColorFadeDrawPending) {
this.mColorFadeDrawPending = true;
this.mChoreographer.postCallback(2, this.mColorFadeDrawRunnable, null);
}
}
private void invokeCleanListenerIfNeeded() {
Runnable listener = this.mCleanListener;
if (listener != null && this.mScreenReady && this.mColorFadeReady) {
this.mCleanListener = null;
listener.run();
}
}
}
| [
"[email protected]"
] | |
de1a3ebab549f248da8ecc02d73c5b7238a476cf | 27b9f8db5436703d09eaa25c1c051def6c9cd115 | /src/main/java/com/github/jacopofar/fleximatcher/expressions/ExpressionParser.java | 78e85485584757af37646bcfc0d81c1010e271c2 | [] | no_license | jacopofar/fleximatcher | d0bc21f15f5cfb81fed8fbe5a2d835b45f7dfc4d | 28387693ff03bf4c73617382a942d006381cb21b | refs/heads/master | 2022-12-29T18:52:21.817295 | 2022-12-13T16:18:46 | 2022-12-13T16:18:46 | 21,500,485 | 6 | 2 | null | null | null | null | UTF-8 | Java | false | false | 2,636 | java | package com.github.jacopofar.fleximatcher.expressions;
import java.util.HashSet;
import java.util.LinkedList;
public class ExpressionParser {
/**
* Split a rule expression and returns an array of chunks
* For example:
* "the dog [pos: verb] the wall"
* will become:
* "the dog ","[pos: verb]"," the wall"
* spaces are preserved, the concatenation of the chunks is the original String
* */
public static String[] split(String pattern) {
//is this just a string?
if(!pattern.contains("[")){
return new String[]{pattern};
}
LinkedList<String> ret=new LinkedList<String>();
int last=0;
int openSquares=0;
for(int k=0;k<pattern.length();k++){
if(pattern.charAt(k)=='[') openSquares++;
if(pattern.charAt(k)==']') openSquares--;
if(pattern.charAt(k)=='[' && openSquares==1){
//just entered an new chunk, store the previous one and update the starting point
ret.add(pattern.substring(last,k));
last=k;
}
if(pattern.charAt(k)==']' && openSquares==0){
//just finished a chunk, store it if it's not empty
ret.add(pattern.substring(last,k+1));
last=k+1;
}
}
//System.out.println("pattern '" + pattern + "' open brackets " + openSquares);
if(openSquares != 0){
//the last pattern was a "fake" one, for example 'aB[r:x'
//it is very likely an user error, refuse it
throw new RuntimeException("Square brackets are unbalanced in pattern '" + pattern + "'");
}
ret.add(pattern.substring(last));
return ret.stream().filter(p->p!=null && p.length()>0).toArray(count->new String[count]);
}
/**
* returns the name of the rule expressed in the chunk
* for example for "[it-pos: Ss]" will return "it-pos"
* it will remove the first squared bracket
* */
public static String ruleName(String s) {
if(s.indexOf(':') == -1)
return s.substring(1, s.length()-1);
return s.substring(1, s.indexOf(':'));
}
/**
* returns the parameter of the rule expressed in the chunk
* for example for "[it-pos: Ss]" will return "Ss"
* it will remove the last squared bracket
* */
public static String getParameter(String s) {
if(s.indexOf(':')==-1)
return "";
return s.substring(s.indexOf(':')+1,s.length()-1);
}
/**
* Returns the set of tags used by this rule
* */
public static HashSet<String> usedTags(String string){
HashSet<String> res=new HashSet<String>();
for(String s:split(string)){
if(ruleName(s).equals("tag"))
res.add(getParameter(s));
if(ruleName(s).equals("multi"))
res.addAll(usedTags(s));
}
return res;
}
}
| [
"[email protected]"
] | |
afe682a6fc94dd1a92e51988fce71d27a4dc7b82 | dcf0d1f9fcf7620163699f60e65dd1f31f38451e | /src/main/java/commands/authentication/SignOutCommand.java | 92597d85fce2c52a5259d32fd14bea60f1373e8d | [] | no_license | dunnyducker/HospitalRez | 983fdc366e41912246a9d41889e558d76782f270 | b6faa3b609d737fb56f2bcc8ce86269ceffd9816 | refs/heads/master | 2022-10-14T22:43:46.626854 | 2019-06-20T19:37:01 | 2019-06-20T19:37:01 | 192,965,634 | 0 | 0 | null | 2022-09-22T18:46:11 | 2019-06-20T18:02:02 | Java | UTF-8 | Java | false | false | 1,179 | java | package commands.authentication;
import commands.ActionCommand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import resource_managers.PageManager;
import utils.CommandResult;
import utils.SessionRequestContent;
public class SignOutCommand implements ActionCommand {
private static final Logger LOGGER = LoggerFactory.getLogger(SignOutCommand.class);
private static SignOutCommand instance;
public static SignOutCommand getInstance() {
if (instance == null) {
synchronized (SignOutCommand.class) {
if (instance == null)
instance = new SignOutCommand();
}
}
return instance;
}
private SignOutCommand() {
LOGGER.info(getClass().getSimpleName() + " instance created!");
}
@Override
public CommandResult execute(SessionRequestContent sessionRequestContent) {
LOGGER.trace("Entering the method");
CommandResult commandResult = new CommandResult(PageManager.getProperty("page.sign_in"), true);
sessionRequestContent.invalidateSession();
LOGGER.trace("Leaving the method");
return commandResult;
}
}
| [
"[email protected]"
] | |
d005acdfe958c0b64f0e39ebb2867d1747947a09 | e4444aa9ae85814d324cf90c1333ca865204fa98 | /src/controller/BdCliente.java | 9ff4064445709db6cc11ecb56e02929d13460753 | [] | no_license | PhlpBrt/Projeto_P2_Biblioteca | e7492edd3a4027056e3f5dc7b9b9dfc3a0389835 | eb960cb8a798bee757672a2adaf2322f968e73f5 | refs/heads/master | 2022-10-12T09:26:40.769652 | 2020-06-09T21:33:09 | 2020-06-09T21:33:09 | 269,851,445 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 4,212 | java | package controller;
import util.CriaConexao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import model.Cliente;
public class BdCliente {
/* ----CONEXÃO COM O BD-> */
private Connection conexao;
// Estabelece uma conexão
public BdCliente() throws SQLException {
this.conexao = CriaConexao.getConnection();
}
/* <-CONEXÃO COM O BD---- */
/* ----CLIENTE-> */
// CREATE - Adiciona um registro
public void adicionaCliente(Cliente c) throws SQLException {
// Prepara conexão p/ receber o comando SQL
PreparedStatement stmt;
String sql = "INSERT INTO cliente(nome, data_nasc, sexo, cpf, endereco, fone)"
+ "VALUES(?, ?, ?, ?, ?, ?)";
// stmt recebe o comando SQL
stmt = this.conexao.prepareStatement(sql);
// Seta os valores p/ o stmt, substituindo os "?"
stmt.setString(1, c.getNome());
stmt.setString(2, c.getDataNasc());
stmt.setString(3, c.getSexo());
stmt.setString(4, c.getCpf());
stmt.setString(5, c.getEndereco());
stmt.setString(6, c.getFone());
// O stmt executa o comando SQL no BD, e fecha a conexão
stmt.execute();
stmt.close();
}
// SELECT - Retorna uma lista com o resultado da consulta
public List<Cliente> getLista(String nome) throws SQLException {
// Prepara conexão p/ receber o comando SQL
String sql = "SELECT * FROM cliente WHERE nome like ?";
PreparedStatement stmt = this.conexao.prepareStatement(sql);
stmt.setString(1, nome);
// Recebe o resultado da consulta SQL
ResultSet rs = stmt.executeQuery();
List<Cliente> lista = new ArrayList<>();
// Enquanto existir registros, pega os valores do ReultSet e vai adicionando na lista
while (rs.next()) {
// A cada loop, é instanciado um novo objeto, p/ servir de ponte no envio de registros p/ a lista
Cliente c = new Cliente();
// "c" -> Cliente novo - .setNome recebe o campo do banco de String "nome"
c.setId(Integer.valueOf(rs.getString("id_cliente")));
c.setNome(rs.getString("nome"));
c.setDataNasc(rs.getString("data_nasc"));
c.setSexo(rs.getString("sexo"));
c.setCpf(rs.getString("cpf"));
c.setEndereco(rs.getString("endereco"));
c.setFone(rs.getString("fone"));
// Adiciona o registro na lista
lista.add(c);
}
// Fecha a conexão com o BD
rs.close();
stmt.close();
// Retorna a lista de registros, gerados pela consulta
return lista;
}
// UPDATE - Atualiza registros
public void altera(Cliente c) throws SQLException {
// Prepara conexão p/ receber o comando SQL
String sql = "UPDATE cliente set nome=?, data_nasc=?, sexo=?, cpf=?, endereco=?, fone=?"
+ "WHERE id_cliente=?";
// stmt recebe o comando SQL
PreparedStatement stmt = this.conexao.prepareStatement(sql);
// Seta os valores p/ o stmt, substituindo os "?"
stmt.setInt(7, c.getId());
stmt.setString(1, c.getNome());
stmt.setString(2, c.getDataNasc());
stmt.setString(3, c.getSexo());
stmt.setString(4, c.getCpf());
stmt.setString(5, c.getEndereco());
stmt.setString(6, c.getFone());
// O stmt executa o comando SQL no BD, e fecha a conexão
stmt.execute();
stmt.close();
}
// DELETE - Apaga registros
public void remove(int id) throws SQLException {
// Prepara conexão p/ receber o comando SQL
String sql = "DELETE FROM cliente WHERE id_cliente=?";
// stmt recebe o comando SQL
PreparedStatement stmt = this.conexao.prepareStatement(sql);
// Seta o valor do ID p/ a condição de verificação SQL, dentro do stmt
stmt.setInt(1, id);
// Executa o codigo SQL, e fecha
stmt.execute();
stmt.close();
}
/* <-CLIENTE---- */
}
| [
"[email protected]"
] | |
8cc9a567e94a71d126a6a2dd1843fd65c1571cfc | 963b1b74f187a5e38fddfe4ca31e5d4d19f40a82 | /demo-angular-boot/src/main/java/com/aldeamo/training/WebSecurityConfiguration.java | 5b796473ad51e68d18006475ce9fa88fb23f8149 | [] | no_license | sancardenasv/Spring-Angular-Base-Project | 07d64b5e0270eeeab23abef430e70f570764098e | b8f514d948eebf52a2b25e7fc7d5f277421d401f | refs/heads/master | 2021-01-22T06:07:12.649763 | 2017-02-12T22:33:59 | 2017-02-12T22:33:59 | 81,736,472 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,301 | java | package com.aldeamo.training;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
protected void configurer(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", "/home").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();
// http.csrf().disable();
}
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth
.inMemoryAuthentication()
.withUser("user").password("password").roles("USER");
}
}
| [
"[email protected]"
] | |
16f91618e8593961be2a9eee6afca00b98b10b37 | 8f5c234b1c1b8e9d26cf78282d5ef949f0bed6dc | /Algorisms/src/part1/Q5.java | e1ab720bc76b063977697383596e3d9432b82e02 | [] | no_license | carensky/Algorithm | 5116975ceab6087fe7b0aa6056c881a85fe364e4 | 3212a94fd817376d99c2f3bb9457cf97d713f147 | refs/heads/master | 2022-03-17T13:27:50.416032 | 2019-12-03T12:32:04 | 2019-12-03T12:32:04 | 195,617,187 | 0 | 0 | null | null | null | null | UHC | Java | false | false | 811 | java | package part1;
import java.util.Scanner;
public class Q5 {
public static void main(String[] args)
{
{
Scanner sc = new Scanner(System.in);
int a, b, c, d;
System.out.println("세 정수의 중간값을 구합니다.");
System.out.print("a의 값：");
a = sc.nextInt();
System.out.print("b의 값：");
b = sc.nextInt();
System.out.print("c의 값：");
c = sc.nextInt();
// a, b, c의 중간값
int cen = cen(a, b, c);
System.out.println("중간값은 " + cen + "입니다.");
}
}
static int cen(int a, int b, int c)
{
if((b >= a && c <= a) || (b <= a && c >= a))
{
return a;
}
else if((a > b && c < b) || (a < b && c > b))
{
return b;
}
else
{
return c;
}
}
}
| [
"[email protected]"
] | |
8752eff6f3b7ec33fba42fda6a62c01afda59157 | 48557b1c41221bab3f9b5a81b9506f21f372e476 | /Java学习笔记/day07_核心类库/src/demo2_admin/Admin.java | a9b067c6950c154ca77846537c96f4056eb9ded2 | [
"MIT"
] | permissive | gaohaibin3000/ttk1907.github.io | 2b4dbc03323fc4eecf2af4adf5300f4a636cf653 | e47d317326189c56b15476e284faa68194cd4dce | refs/heads/master | 2020-08-29T05:12:22.489840 | 2019-10-28T02:28:21 | 2019-10-28T02:28:21 | 217,938,942 | 0 | 0 | MIT | 2019-10-28T00:57:34 | 2019-10-28T00:57:34 | null | UTF-8 | Java | false | false | 796 | java | package demo2_admin;
import java.util.Scanner;
public class Admin {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入账户和密码:");
for (int i=0;i<5;i++){
String s1 = s.next();
String s2 = s.next();
if (s1.equals("admin") && s2.equals("123456")){
System.out.println("登陆成功！");
break;
}else {
if (i==2){
System.out.println("用户名或密码输入错误！账户已冻结，请联系客服人员");
break;
}
System.out.println("用户名或密码输入错误！您还有"+(2-i)+"次机会！");
}
}
}
}
| [
"[email protected]"
] | |
6a72b9d90df24429d4a4ed02d645a408464da7a7 | 9789d56a7fec84ce79aa740d1df04ea33bcbcbc5 | /wallet-job/src/main/java/com/jinglitong/wallet/job/mapper/DdbShoreholderRuleMapper.java | ace575a83e9ddf1938d1f0f765c5b805ac0138de | [] | no_license | lombook/ddb-wallet | 373b0d2435d7152b962b898646541b2b5c6c85a8 | 29d4ec4eb4746623e3b4540b9d5694110191dc28 | refs/heads/master | 2020-05-19T18:55:20.423699 | 2019-05-06T09:31:05 | 2019-05-06T09:31:05 | 185,162,085 | 1 | 2 | null | null | null | null | UTF-8 | Java | false | false | 236 | java | package com.jinglitong.wallet.job.mapper;
import com.jinglitong.wallet.ddbapi.model.DdbShoreholderRule;
import com.jinglitong.wallet.job.util.MyMapper;
public interface DdbShoreholderRuleMapper extends MyMapper<DdbShoreholderRule> {
} | [
"[email protected]"
] | |
224834be2d6f3c192f9c8d2a0f8c89be900e624a | 70021f9057fa5e899a26af05ee03baee99daff90 | /src/main/java/com/qhwl/admin/sys/web/UserController.java | 9d35884fcb45af2163d9a03d446bf17211f7fed4 | [] | no_license | ztj666/jeesite | 40385c802accabc5369772457938b1950d06005b | 2f44172e1fa1bf6aea6068255aa0ec1f2ed6e490 | refs/heads/master | 2020-04-08T10:08:29.170394 | 2018-11-27T05:44:11 | 2018-11-27T05:44:11 | 159,256,159 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 13,223 | java | /**
* Copyright © 2015-2050 谦亨科技 All rights reserved.
*/
package com.qhwl.admin.sys.web;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.ConstraintViolationException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.qhwl.admin.sys.entity.Office;
import com.qhwl.admin.sys.entity.Role;
import com.qhwl.admin.sys.entity.User;
import com.qhwl.admin.sys.service.SystemService;
import com.qhwl.admin.sys.utils.UserUtils;
import com.qhwl.common.beanvalidator.BeanValidators;
import com.qhwl.common.config.Global;
import com.qhwl.common.persistence.Page;
import com.qhwl.common.utils.DateUtils;
import com.qhwl.common.utils.StringUtils;
import com.qhwl.common.utils.excel.ExportExcel;
import com.qhwl.common.utils.excel.ImportExcel;
import com.qhwl.common.web.BaseController;
/**
* 用户Controller
* @author Admin
* @version 2013-8-29
*/
@Controller
@RequestMapping(value = "${adminPath}/sys/user")
public class UserController extends BaseController {
@Autowired
private SystemService systemService;
@ModelAttribute
public User get(@RequestParam(required=false) String id) {
if (StringUtils.isNotBlank(id)){
return systemService.getUser(id);
}else{
return new User();
}
}
@RequiresPermissions("sys:user:view")
@RequestMapping(value = {"index"})
public String index(User user, Model model) {
return "admin/sys/userIndex";
}
@RequiresPermissions("sys:user:view")
@RequestMapping(value = {"list", ""})
public String list(User user, HttpServletRequest request, HttpServletResponse response, Model model) {
Page<User> page = systemService.findUser(new Page<User>(request, response), user);
model.addAttribute("page", page);
return "admin/sys/userList";
}
@ResponseBody
@RequiresPermissions("sys:user:view")
@RequestMapping(value = {"listData"})
public Page<User> listData(User user, HttpServletRequest request, HttpServletResponse response, Model model) {
Page<User> page = systemService.findUser(new Page<User>(request, response), user);
return page;
}
@RequiresPermissions("sys:user:view")
@RequestMapping(value = "form")
public String form(User user, Model model) {
if (user.getCompany()==null || user.getCompany().getId()==null){
user.setCompany(UserUtils.getUser().getCompany());
}
if (user.getOffice()==null || user.getOffice().getId()==null){
user.setOffice(UserUtils.getUser().getOffice());
}
model.addAttribute("user", user);
model.addAttribute("allRoles", systemService.findAllRole());
return "admin/sys/userForm";
}
@RequiresPermissions("sys:user:edit")
@RequestMapping(value = "save")
public String save(User user, HttpServletRequest request, Model model, RedirectAttributes redirectAttributes) {
if(Global.isDemoMode()){
addMessage(redirectAttributes, "演示模式，不允许操作！");
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
// 修正引用赋值问题，不知道为何，Company和Office引用的一个实例地址，修改了一个，另外一个跟着修改。
user.setCompany(new Office(request.getParameter("company.id")));
user.setOffice(new Office(request.getParameter("office.id")));
// 如果新密码为空，则不更换密码
if (StringUtils.isNotBlank(user.getNewPassword())) {
user.setPassword(SystemService.entryptPassword(user.getNewPassword()));
}
if (!beanValidator(model, user)){
return form(user, model);
}
if (!"true".equals(checkLoginName(user.getOldLoginName(), user.getLoginName()))){
addMessage(model, "保存用户'" + user.getLoginName() + "'失败，登录名已存在");
return form(user, model);
}
// 角色数据有效性验证，过滤不在授权内的角色
List<Role> roleList = Lists.newArrayList();
List<String> roleIdList = user.getRoleIdList();
for (Role r : systemService.findAllRole()){
if (roleIdList.contains(r.getId())){
roleList.add(r);
}
}
user.setRoleList(roleList);
// 保存用户信息
systemService.saveUser(user);
// 清除当前用户缓存
if (user.getLoginName().equals(UserUtils.getUser().getLoginName())){
UserUtils.clearCache();
//UserUtils.getCacheMap().clear();
}
addMessage(redirectAttributes, "保存用户'" + user.getLoginName() + "'成功");
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
@RequiresPermissions("sys:user:edit")
@RequestMapping(value = "delete")
public String delete(User user, RedirectAttributes redirectAttributes) {
if(Global.isDemoMode()){
addMessage(redirectAttributes, "演示模式，不允许操作！");
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
if (UserUtils.getUser().getId().equals(user.getId())){
addMessage(redirectAttributes, "删除用户失败, 不允许删除当前用户");
}else if (User.isAdmin(user.getId())){
addMessage(redirectAttributes, "删除用户失败, 不允许删除超级管理员用户");
}else{
systemService.deleteUser(user);
addMessage(redirectAttributes, "删除用户成功");
}
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
/**
* 导出用户数据
* @param user
* @param request
* @param response
* @param redirectAttributes
* @return
*/
@RequiresPermissions("sys:user:view")
@RequestMapping(value = "export", method=RequestMethod.POST)
public String exportFile(User user, HttpServletRequest request, HttpServletResponse response, RedirectAttributes redirectAttributes) {
try {
String fileName = "用户数据"+DateUtils.getDate("yyyyMMddHHmmss")+".xlsx";
Page<User> page = systemService.findUser(new Page<User>(request, response, -1), user);
new ExportExcel("用户数据", User.class).setDataList(page.getList()).write(response, fileName).dispose();
return null;
} catch (Exception e) {
addMessage(redirectAttributes, "导出用户失败！失败信息："+e.getMessage());
}
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
/**
* 导入用户数据
* @param file
* @param redirectAttributes
* @return
*/
@RequiresPermissions("sys:user:edit")
@RequestMapping(value = "import", method=RequestMethod.POST)
public String importFile(MultipartFile file, RedirectAttributes redirectAttributes) {
if(Global.isDemoMode()){
addMessage(redirectAttributes, "演示模式，不允许操作！");
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
try {
int successNum = 0;
int failureNum = 0;
StringBuilder failureMsg = new StringBuilder();
ImportExcel ei = new ImportExcel(file, 1, 0);
List<User> list = ei.getDataList(User.class);
for (User user : list){
try{
if ("true".equals(checkLoginName("", user.getLoginName()))){
user.setPassword(SystemService.entryptPassword("123456"));
BeanValidators.validateWithException(validator, user);
systemService.saveUser(user);
successNum++;
}else{
failureMsg.append("<br/>登录名 "+user.getLoginName()+" 已存在; ");
failureNum++;
}
}catch(ConstraintViolationException ex){
failureMsg.append("<br/>登录名 "+user.getLoginName()+" 导入失败：");
List<String> messageList = BeanValidators.extractPropertyAndMessageAsList(ex, ": ");
for (String message : messageList){
failureMsg.append(message+"; ");
failureNum++;
}
}catch (Exception ex) {
failureMsg.append("<br/>登录名 "+user.getLoginName()+" 导入失败："+ex.getMessage());
}
}
if (failureNum>0){
failureMsg.insert(0, "，失败 "+failureNum+" 条用户，导入信息如下：");
}
addMessage(redirectAttributes, "已成功导入 "+successNum+" 条用户"+failureMsg);
} catch (Exception e) {
addMessage(redirectAttributes, "导入用户失败！失败信息："+e.getMessage());
}
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
/**
* 下载导入用户数据模板
* @param response
* @param redirectAttributes
* @return
*/
@RequiresPermissions("sys:user:view")
@RequestMapping(value = "import/template")
public String importFileTemplate(HttpServletResponse response, RedirectAttributes redirectAttributes) {
try {
String fileName = "用户数据导入模板.xlsx";
List<User> list = Lists.newArrayList(); list.add(UserUtils.getUser());
new ExportExcel("用户数据", User.class, 2).setDataList(list).write(response, fileName).dispose();
return null;
} catch (Exception e) {
addMessage(redirectAttributes, "导入模板下载失败！失败信息："+e.getMessage());
}
return "redirect:" + adminPath + "/sys/user/list.do?repage";
}
/**
* 验证登录名是否有效
* @param oldLoginName
* @param loginName
* @return
*/
@ResponseBody
@RequiresPermissions("sys:user:edit")
@RequestMapping(value = "checkLoginName")
public String checkLoginName(String oldLoginName, String loginName) {
if (loginName !=null && loginName.equals(oldLoginName)) {
return "true";
} else if (loginName !=null && systemService.getUserByLoginName(loginName) == null) {
return "true";
}
return "false";
}
/**
* 用户信息显示及保存
* @param user
* @param model
* @return
*/
@RequiresPermissions("user")
@RequestMapping(value = "info")
public String info(User user, HttpServletResponse response, Model model) {
User currentUser = UserUtils.getUser();
if (StringUtils.isNotBlank(user.getName())){
if(Global.isDemoMode()){
model.addAttribute("message", "演示模式，不允许操作！");
return "admin/sys/userInfo";
}
currentUser.setEmail(user.getEmail());
currentUser.setPhone(user.getPhone());
currentUser.setMobile(user.getMobile());
currentUser.setRemarks(user.getRemarks());
currentUser.setPhoto(user.getPhoto());
systemService.updateUserInfo(currentUser);
model.addAttribute("message", "保存用户信息成功");
}
model.addAttribute("user", currentUser);
model.addAttribute("Global", new Global());
return "admin/sys/userInfo";
}
/**
* 返回用户信息
* @return
*/
@RequiresPermissions("user")
@ResponseBody
@RequestMapping(value = "infoData")
public User infoData() {
return UserUtils.getUser();
}
/**
* 修改个人用户密码
* @param oldPassword
* @param newPassword
* @param model
* @return
*/
@RequiresPermissions("user")
@RequestMapping(value = "modifyPwd")
public String modifyPwd(String oldPassword, String newPassword, Model model) {
User user = UserUtils.getUser();
if (StringUtils.isNotBlank(oldPassword) && StringUtils.isNotBlank(newPassword)){
if(Global.isDemoMode()){
model.addAttribute("message", "演示模式，不允许操作！");
return "admin/sys/userModifyPwd";
}
if (SystemService.validatePassword(oldPassword, user.getPassword())){
systemService.updatePasswordById(user.getId(), user.getLoginName(), newPassword);
model.addAttribute("message", "修改密码成功");
}else{
model.addAttribute("message", "修改密码失败，旧密码错误");
}
}
model.addAttribute("user", user);
return "admin/sys/userModifyPwd";
}
@RequiresPermissions("user")
@ResponseBody
@RequestMapping(value = "treeData")
public List<Map<String, Object>> treeData(@RequestParam(required=false) String officeId, HttpServletResponse response) {
List<Map<String, Object>> mapList = Lists.newArrayList();
List<User> list = systemService.findUserByOfficeId(officeId);
for (int i=0; i<list.size(); i++){
User e = list.get(i);
Map<String, Object> map = Maps.newHashMap();
map.put("id", "u_"+e.getId());
map.put("pId", officeId);
map.put("name", StringUtils.replace(e.getName(), " ", ""));
mapList.add(map);
}
return mapList;
}
// @InitBinder
// public void initBinder(WebDataBinder b) {
// b.registerCustomEditor(List.class, "roleList", new PropertyEditorSupport(){
// @Autowired
// private SystemService systemService;
// @Override
// public void setAsText(String text) throws IllegalArgumentException {
// String[] ids = StringUtils.split(text, ",");
// List<Role> roles = new ArrayList<Role>();
// for (String id : ids) {
// Role role = systemService.getRole(Long.valueOf(id));
// roles.add(role);
// }
// setValue(roles);
// }
// @Override
// public String getAsText() {
// return Collections3.extractToString((List) getValue(), "id", ",");
// }
// });
// }
}
| [
"[email protected]"
] | |
24bdab1f34c3b8b9267811a9f78f78f4e4e82cc8 | 21d5c1ec01974a7653d5459643be2602bc18a2a6 | /src/main/java/com/marcelino/apirest/repositories/VendaRepository.java | 7f7bf3e4fe7433d1c855b4f9c350851e95892b00 | [] | no_license | dcmarcelino/EDITH-backend | 41e7aa716d62713684f7bd0c284c039849693fdb | 8ee950e34779a4cddc2cf9bc4732922c6dcb95a0 | refs/heads/master | 2020-08-12T19:37:35.472489 | 2019-10-20T16:38:55 | 2019-10-20T16:38:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 441 | java | package com.marcelino.apirest.repositories;
import org.springframework.data.jpa.repository.JpaRepository;
import com.marcelino.apirest.models.Venda;
public interface VendaRepository extends JpaRepository<Venda, Long> {
/*
* Essa classe é a classe de persistencia do objeto, pode ser adicionados métodos personalizados
*/
public Venda findById(long id); // cria um método para buscar por id, usando o id definido na classe
}
| [
"[email protected]"
] | |
da932c45a40420fcdf3e69d2b7737d8e364fcbce | e9c820922522f2ff3c92899c18db657bb4ef9212 | /login-project/src/main/java/com/loginproject/jwt_config/Login_security_config/JwtAuthenticationEntryPointExceptionHandler.java | 3c525c394ac4bb7191b1a2ffaf44109cd5d0c33c | [] | no_license | Ankit-Goswami773/Login | 56afffa0dea76cdeedcdfbb41263e6ba29a4717c | af8a0d47d3d9364b9704be68a7637cc220fcd738 | refs/heads/main | 2023-09-02T16:14:41.827950 | 2021-11-15T13:28:44 | 2021-11-15T13:28:44 | 428,264,179 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 846 | java | package com.loginproject.jwt_config.Login_security_config;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
@Component
public class JwtAuthenticationEntryPointExceptionHandler implements AuthenticationEntryPoint {
/** this class is us for custom error message and status code when Unauthorized user send request */
@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException) throws IOException, ServletException {
response.sendError(401, "Unauthorized");
}
}
| [
"[email protected]"
] | |
0baa276e83384e76eef2d444c20ea3d0d0e9b824 | 12898543b47620917287f9cd30e2d0a8086490a0 | /app/src/main/java/com/yoon/memoria/Quiz/QuizActivity.java | 8c9a147297b199c3e7bdc1121b0c803a9a76f083 | [] | no_license | 729533572/Marks | 07979a6498f250fd4534e0b97f13f36f6b258cd5 | f34739ce2b6101d3a3832ece409c1f1c09e26783 | refs/heads/master | 2020-04-04T09:35:34.549339 | 2018-07-26T08:58:48 | 2018-07-26T08:58:48 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,472 | java | package com.yoon.memoria.Quiz;
import android.databinding.DataBindingUtil;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.util.Log;
import android.view.MenuItem;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
import com.yoon.memoria.Main.Fragment.Place.PlaceRecyclerViewAdapter;
import com.yoon.memoria.Model.Place;
import com.yoon.memoria.Model.User;
import com.yoon.memoria.R;
import com.yoon.memoria.UidSingleton;
import com.yoon.memoria.Util.Util;
import com.yoon.memoria.databinding.ActivityQuizBinding;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class QuizActivity extends AppCompatActivity implements QuizContract.View,ValueEventListener {
private ActivityQuizBinding binding;
private DatabaseReference databaseReference;
private UidSingleton uidSingleton = UidSingleton.getInstance();
private QuizRecyclerViewAdapter adapter;
private QuizPresenter presenter;
private int ANSWER;
public int quizCount;
public int ansCount;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = DataBindingUtil.setContentView(this, R.layout.activity_quiz);
binding.setActivity(this);
databaseReference = FirebaseDatabase.getInstance().getReference();
presenter = new QuizPresenter(this);
initToolbar();
setRecyclerView();
}
public void initToolbar(){
setSupportActionBar(binding.quizToolbar);
getSupportActionBar().setDisplayShowCustomEnabled(true);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setHomeAsUpIndicator(R.drawable.ic_arrow_back_white_48dp);
getSupportActionBar().setTitle(null);
}
public void setRecyclerView(){
binding.quizRecyclerView.setLayoutManager(new GridLayoutManager(this,2));
adapter = new QuizRecyclerViewAdapter(this,this);
binding.quizRecyclerView.setAdapter(adapter);
}
public void setData(List<Place> questions, int answer){
binding.quizQuestion.setText(questions.get(answer).getDetail() + "쯤에");
binding.quizQuestion1.setText(" 어디에 방문하셨습니까?");
adapter.addItems(questions);
}
@Override
public void onStart() {
databaseReference.child("users").child(uidSingleton.getUid()).addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
User user = dataSnapshot.getValue(User.class);
quizCount = user.getQuizCount();
ansCount = user.getAnsCount();
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
databaseReference.child("users").child(uidSingleton.getUid()).child("places").addListenerForSingleValueEvent(this);
super.onStart();
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
switch (id)
{
case android.R.id.home:
finish();
break;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
List<Place> places = new ArrayList<>(0);
List<String> placenames = new ArrayList<>(0);
List<Place> questions = new ArrayList<>(0);
int i = 0;
for(DataSnapshot snapshot : dataSnapshot.getChildren()){
Place place = snapshot.getValue(Place.class);
places.add(place);
}
if(places.size() > 0) {
Collections.shuffle(places);
do {
if (!placenames.contains(places.get(i).getPlaceName())) {
questions.add(places.get(i));
placenames.add(places.get(i).getPlaceName());
}
i++;
} while (!(questions.size() == 4 || i == places.size()));
if (questions.size() == 4) {
ANSWER = (int) (Math.random() * 4);
setData(questions, ANSWER);
} else
Util.makeToast(this, "방문하신 장소가 부족합니다!");
}
else
Util.makeToast(this, "방문하신 장소가 부족합니다!");
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
@Override
public void check(int i) {
quizCount++;
databaseReference.child("users").child(uidSingleton.getUid()).child("quizCount").setValue(quizCount);
if(ANSWER == i) {
ansCount++;
databaseReference.child("users").child(uidSingleton.getUid()).child("ansCount").setValue(ansCount);
Util.makeToast(this, "정답입니다!");
databaseReference.child("users").child(uidSingleton.getUid()).child("places").addListenerForSingleValueEvent(this);
}
else
Util.makeToast(this,"오답입니다!ㅠ");
}
}
| [
"[email protected]"
] | |
acc2ebaebc45f937954308eba602992b65b297f8 | 1081e090fc5107cbdb1bebdef8dacba2d249ec86 | /gboss-gateway-315/.svn/pristine/fa/fabfa5d010d40d7e1f6ab02edf1b99266d1c1b06.svn-base | c8960bdbc10b5bec1fab0f3fbaa713d65cc3da71 | [] | no_license | ysylmqq/segWorkspace | ec9c992ef74897a4078ebd456a605e94d93ac3a1 | 3f621fb57dd285e3a6549f34aa45f4ff1df7098a | refs/heads/master | 2021-05-10T08:27:59.458352 | 2018-01-26T00:39:31 | 2018-01-26T00:39:31 | 118,879,439 | 4 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,368 | package cc.chinagps.gateway.unit.oem.test;
import java.util.ArrayList;
import java.util.List;
import javax.jms.JMSException;
import cc.chinagps.gateway.log.LogManager;
import cc.chinagps.gateway.mq.MQManager;
import cc.chinagps.gateway.mq.export.ExportMQMult;
import cc.chinagps.gateway.seat.cmd.CmdUtil;
public class Sender {
public static void navi(ExportMQMult exportMQMult) {
String callLetter = "14910261884";
int cmdId = CmdUtil.CMD_ID_SET_TARGET_QUERY_POINT;
// cmdId = CmdUtil.CMD_ID_DELIVER_ORDER;
List<String> params = new ArrayList<String>();
params.add("0");
params.add("114.27757300");
params.add("22.68334500");
try {
exportMQMult.addCommand(callLetter, cmdId, params);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void position(ExportMQMult exportMQMult){
String callLetter = "1613912345001";
int cmdId =CmdUtil.CMD_ID_POSITION;
List<String> params = new ArrayList<String>();
try {
exportMQMult.addCommand(callLetter, cmdId , params);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void remoteControl(ExportMQMult exportMQMult) {
String callLetter = "13800000088";
int cmdId = CmdUtil.CMD_ID_REMOTE_CONTROL_VEHICLE;
List<String> params = new ArrayList<String>();
params.add("1");
try {
exportMQMult.addCommand(callLetter, cmdId, params);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void accOffDeliver(ExportMQMult exportMQMult,boolean action, int secs) {
String callLetter = "64854664565";
int cmdId = action == true ? CmdUtil.CMD_ID_START_ACC_OFF_DELIVERY : CmdUtil.CMD_ID_STOP_ACC_OFF_DELIVERY;
List<String> params = new ArrayList<String>();
params.add(secs+"");
try {
exportMQMult.addCommand(callLetter, cmdId, params);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
ExportMQMult exportMQMult = new ExportMQMult();
LogManager.init();
MQManager.init();
try {
exportMQMult.init();
//navi(exportMQMult);
//accOffDeliver(exportMQMult, true, 10);
position(exportMQMult);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
| [
"[email protected]"
] | ||
dd0ed2d2649240fd67dfece87717dbdadbb84c59 | 2347d860d735575e4413cf92eb9aa3e698d812e7 | /src/br/com/rafaelbarata/Combinacoes.java | fbad216572bc467e0c211e439ebdc1c19e08f5e1 | [] | no_license | rafaelbarata/AnaliseCombinatoria | cf3030482892e140a29bc5d0354d4c1eb845e108 | 8b9bd93c3e69b30d0499eea5cf948d391d6cbe12 | refs/heads/master | 2020-05-17T15:28:30.958003 | 2019-04-27T18:41:49 | 2019-04-27T18:41:49 | 183,789,964 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,147 | java | package br.com.rafaelbarata;
import java.util.Arrays;
import java.util.List;
public class Combinacoes {
private Integer numeros[] = { 1, 2, 3, 4, 5, 6, 7 };
private static int quantidade = 6;
private int resultado[] = new int[quantidade];
private int count = 0;
private List<Integer> listaDeNumeros;
private void busca(int inicio, int fim, int profundidade) {
if ((profundidade + 1) >= quantidade) {
for (int x = inicio; x <= fim; x++) {
resultado[profundidade] = numeros[x];
// faz alguma coisa com um dos resultados possiveis
count++;
for (int i = 0; i < quantidade; i++) {
System.out.print(resultado[i] + (i < quantidade - 1 ? ", " : "\n"));
}
}
} else
for (int x = inicio; x <= fim; x++) {
resultado[profundidade] = numeros[x];
busca(x + 1, fim + 1, profundidade + 1);
}
}
public static void main(String args[]) {
Combinacoes comb = new Combinacoes();
comb.listaDeNumeros = Arrays.asList(comb.numeros);
comb.busca(0, (comb.listaDeNumeros.size() - quantidade), 0);
System.out.println("Total de combinacoes: " + comb.count);
}
} | [
"[email protected]"
] | |
b2b918cc030bbf1492f215719dbf5245e372ec73 | dbfdac1ba3c15d8992fffff5cbc6c62377c0e81e | /heapStackQueue/SlidingWindowMedian.java | bcef014a82f5ed8fb13d4b2e25cd28bfe6cb89a7 | [] | no_license | yzzyq/leetcode | 27e7fc1f0796fbb36ce8e169efe7c7ed301d612f | ac765db26cbe99f311d1fe72a643276ff019d625 | refs/heads/main | 2023-04-09T00:00:40.592691 | 2021-04-13T03:50:30 | 2021-04-13T03:50:30 | 280,605,247 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 5,343 | java | package heapStackQueue;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.PriorityQueue;
/**
* 480. Sliding Window Median
*
* Median is the middle value in an ordered integer list. If the size of the list is even,
* there is no middle value. So the median is the mean of the two middle value.
Examples:
[2,3,4] , the median is 3
[2,3], the median is (2 + 3) / 2 = 2.5
Given an array nums, there is a sliding window of size k which is moving from the very left of the
array to the very right. You can only see the k numbers in the window. Each time the sliding
window moves right by one position. Your job is to output the median array for each window in
the original array.
For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.
Window position Median
--------------- -----
[1 3 -1] -3 5 3 6 7 1
1 [3 -1 -3] 5 3 6 7 -1
1 3 [-1 -3 5] 3 6 7 -1
1 3 -1 [-3 5 3] 6 7 3
1 3 -1 -3 [5 3 6] 7 5
1 3 -1 -3 5 [3 6 7] 6
Therefore, return the median sliding window as [1,-1,-1,3,5,6].
Note:
You may assume k is always valid, ie: k is always smaller than input array's size for non-empty
array.
Answers within 10^-5 of the actual value will be accepted as correct.
*
*/
// 找出每次移动窗口的中位数
// 这题，java并没有什么解法，大多数都是双堆解法，建议先理解295Find Median from Data Stream那题，解法一样
// C++语言的话，还有一种多重集合+迭代器的方法
public class SlidingWindowMedian {
// 超时
public double[] medianSlidingWindow(int[] nums, int k) {
int size = nums.length - k + 1;
double[] medians = new double[size];
Deque<Integer> queue = new LinkedList<Integer>();
int num = 0;
for(int index = 0; index < nums.length; index++) {
queue.offer(nums[index]);
if(queue.size() == k) {
// 得到中位数
Object[] arr = queue.toArray();
Arrays.sort(arr);
if(k % 2 == 0) {
int median = k / 2;
medians[num] = (Long.parseLong(arr[median].toString()) +
Long.parseLong(arr[median - 1].toString())) / 2.0;
}else {
medians[num] = (int)arr[k / 2];
}
num++;
queue.poll();
}
}
return medians;
}
// 双堆解法，主要要解决的就是滑动删除元素的问题，这里采用的就是延迟删除
// 就是只在它在堆顶的时候再删除，其他位置都不删除，只要维持俩个堆的平衡即可
public double[] medianSlidingWindow_1(int[] nums, int k) {
int size = nums.length - k + 1;
double[] medians = new double[size];
HashMap<Integer, Integer> useless_node = new HashMap<Integer, Integer>();
PriorityQueue<Integer> max_heap = new PriorityQueue<Integer>((a,b) -> b.compareTo(a));
PriorityQueue<Integer> min_heap = new PriorityQueue<Integer>();
int pos = 0;
// 首先进行初始设置
for(;pos < k; pos++) max_heap.offer(nums[pos]);
for(int j = 0;j < k/2;j++) min_heap.offer(max_heap.poll());
int median_index = 0;
// 这里使用for的话，就会丢失nums只有俩个数，滑动也是2的情况
while(true) {
// 提取出中位数
medians[median_index++] = ((k & 1) == 0)?((double)max_heap.peek() +
(double)min_heap.peek())/2.0:max_heap.peek();
if(pos >= nums.length) break;
int balance = 0;
// 删除操作是会引起不平衡，但是这个不平衡是反过来的
balance += (nums[pos - k] <= max_heap.peek()?1:-1);
// 进行添加，需要保持平衡
useless_node.put(nums[pos - k], useless_node.getOrDefault(nums[pos - k], 0)+1);
if(!max_heap.isEmpty() && nums[pos] <= max_heap.peek()) {
--balance;
max_heap.offer(nums[pos++]);
}else{
++balance;
min_heap.offer(nums[pos++]);
}
if(balance > 0) {
--balance;
max_heap.offer(min_heap.poll());
}else if(balance < 0) {
++balance;
min_heap.offer(max_heap.poll());
}
// 如果删除元素就在堆顶，那么删除,也需要从map中删除
while(!max_heap.isEmpty() && useless_node.getOrDefault(max_heap.peek(), 0) > 0) {
int temp = max_heap.poll();
useless_node.put(temp, useless_node.get(temp) - 1);
}
while(!min_heap.isEmpty() && useless_node.getOrDefault(min_heap.peek(), 0) > 0) {
int temp = min_heap.poll();
useless_node.put(temp, useless_node.get(temp) - 1);
}
}
return medians;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
var swm = new SlidingWindowMedian();
// int[] nums = {2147483647,2147483647};
// int k = 2;
int[] nums = {1,2,3,4,2,3,1,4,2};
int k = 3;
double[] medians = swm.medianSlidingWindow_1(nums, k);
for(double one_median:medians) {
System.out.print(one_median + ",");
}
}
}
| [
"[email protected]"
] | |
640606d6368f44250c738ad1bdb14eeedf56742f | e8104e6b8ce896c2b7fbde30f1cd681db8b501f3 | /app/src/main/java/async_tasks/general/BuyLinkFetch.java | fb294c7aaf0b80dc6c8f700f3f25bafed17aa8a7 | [] | no_license | jamesyrose/AndroidApp | ccfc06a7df450b47a8f440624e394bb8e7fafdab | e214b26885f0f066b929e14be39a8a37dc75d3cd | refs/heads/master | 2022-12-28T16:35:30.100871 | 2020-10-14T04:30:33 | 2020-10-14T04:30:33 | 303,902,919 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,049 | java | package pcpp_data.backflow;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Build;
import androidx.annotation.RequiresApi;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Attribute;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Iterator;
import pcpp_data.constants.SqlConstants;
import pcpp_data.sqllite.database;
public class BuyLinkFetch extends AsyncTask<String, Void, ArrayList<String>> {
int productID;
String merchant;
Context context;
String productName, productType, productNum;
public BuyLinkFetch (Context context,int productID, String merchant){
this.productID = productID;
this.merchant = merchant;
this.context = context;
}
@Override
protected ArrayList<String> doInBackground(String... strings) {
if (merchant.equals("Amazon")){
amazonURL();
}
return null;
}
public String amazonURL(){
String base = "https://www.amazon.com/s?k=%s&i=electronics" ;
getPartNum();
String url = String.format(base, productNum);
try {
System.out.println(url);
Document doc = Jsoup.connect(url)
.userAgent("Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36")
.maxBodySize(0)
.referrer("http://www.google.com")
.followRedirects(false)
.get();
String productLink = "";
String price = "";
for (Element element: doc.getAllElements()) {
for (Attribute attr : element.attributes()) {
if (attr.getKey().equals("data-index") && attr.getValue().equals("0")) {
for (Element ele: element.getAllElements()) {
for (Attribute subAtter: ele.attributes()) {
if (subAtter.getKey().equals("href")) {
productLink += "https://www.amazon.com" + subAtter.getValue();
System.out.println(productLink);
}
// if (subAtter.getKey().equals("class") && subAtter.getValue().equals("a-price")){
// if (price.equals("")){
// price += ele.text();
// }
// }
}
}
}
}
}
System.out.println(price + " " + productLink);
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
private void getPartNum(){
String firstSql = String.format("SELECT ProductName, ProductType FROM ProductMain WHERE ProductID = %d", productID);
JSONArray firstBuff = new database(context).getData(firstSql);
productName = (String) ((JSONObject) firstBuff.get(0)).get("ProductName");
productType = (String) ((JSONObject) firstBuff.get(0)).get("ProductType");
String secondSql = String.format("SELECT `Part #` FROM %s WHERE ProductID = %d", productType, productID);
JSONArray secondBuff = new database(context).getData(secondSql);
productNum = (String) ((JSONObject) secondBuff.get(0)).get("Part #");
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
private static String encodeValue(String value) {
try {
return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException(ex.getCause());
}
}
}
| [
"[email protected]"
] | |
1b7fff5a6d3b8d982a3d1afcaafd78c117c090aa | 7594bacd5d6b78d87c31669bb66356fbb0b943f6 | /TrackingWebservices/TrackingServicesGateway/src/cl/movistar/ofertador/services/OfertadorImpl.java | 466b1797db279a1cca9aad69457d816e3c0126ce | [] | no_license | EquipoV/Tracking | da1771162dab889d7fa1fc1d70ffc7e0f5764fd3 | a2e9565688255d2af45c7ccbdf283cbb1a76e80f | refs/heads/master | 2021-01-02T09:08:54.373042 | 2014-07-03T17:21:08 | 2014-07-03T17:21:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 974 | java | /**
* OfertadorImpl.java
*
* This file was auto-generated from WSDL
* by the Apache Axis 1.4 Apr 22, 2006 (06:55:48 PDT) WSDL2Java emitter.
*/
package cl.movistar.ofertador.services;
public interface OfertadorImpl extends java.rmi.Remote {
public cl.movistar.ofertador.dto.Response validarCompatibilidadEntreOfertas(cl.movistar.ofertador.dto.SolicitudCompatibilidadOferta solicitudCompatibilidadOferta) throws java.rmi.RemoteException;
public cl.movistar.ofertador.dto.Response validarFactibilidadVentaOtrosCanales(cl.movistar.ofertador.dto.SolicitudFactibilidadVentaOtrosCanales solicitudFactibilidadVentaOtrosCanales) throws java.rmi.RemoteException;
public cl.movistar.ofertador.dto.ResponseOfertas obtenerOfertas(cl.movistar.ofertador.dto.SolicitudOferta solicitudOferta) throws java.rmi.RemoteException;
public cl.movistar.ofertador.dto.ResponseDetalleOferta obtenerDetalleOferta(java.lang.String codigoOferta) throws java.rmi.RemoteException;
}
| [
"[email protected]"
] | |
88ef2e2881cfac12cf3575ead4e62cc640d15fb3 | a0a811e4f97a8f902eeb7564ba38912a095ee960 | /LAB5/TermiteCMov/Termite-WifiP2P-SimpleChat/src/main/java/pt/inesc/termite/simplechat/SimWifiP2pBroadcastReceiver.java | c463c17fc9493483f2051a79a40153e06d7bf993 | [] | no_license | EdFil/CMOV | ece170d1162ad0930eba3475e359dea27de638c4 | c5ec88899b487776881bbbdbce7e8bdb829bc5dc | refs/heads/master | 2021-01-23T10:43:52.484621 | 2015-05-15T22:46:19 | 2015-05-15T22:46:19 | 31,206,975 | 1 | 3 | null | null | null | null | UTF-8 | Java | false | false | 2,463 | java | package pt.inesc.termite.simplechat;
import pt.inesc.termite.wifidirect.SimWifiP2pBroadcast;
import pt.inesc.termite.wifidirect.SimWifiP2pInfo;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;
public class SimWifiP2pBroadcastReceiver extends BroadcastReceiver {
private SimpleChatActivity mActivity;
public SimWifiP2pBroadcastReceiver(SimpleChatActivity activity) {
super();
this.mActivity = activity;
}
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (SimWifiP2pBroadcast.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
// This action is triggered when the WDSim service changes state:
// - creating the service generates the WIFI_P2P_STATE_ENABLED event
// - destroying the service generates the WIFI_P2P_STATE_DISABLED event
int state = intent.getIntExtra(SimWifiP2pBroadcast.EXTRA_WIFI_STATE, -1);
if (state == SimWifiP2pBroadcast.WIFI_P2P_STATE_ENABLED) {
Toast.makeText(mActivity, "WiFi Direct enabled",
Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(mActivity, "WiFi Direct disabled",
Toast.LENGTH_SHORT).show();
}
} else if (SimWifiP2pBroadcast.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
// Request available peers from the wifi p2p manager. This is an
// asynchronous call and the calling activity is notified with a
// callback on PeerListListener.onPeersAvailable()
Toast.makeText(mActivity, "Peer list changed",
Toast.LENGTH_SHORT).show();
} else if (SimWifiP2pBroadcast.WIFI_P2P_NETWORK_MEMBERSHIP_CHANGED_ACTION.equals(action)) {
SimWifiP2pInfo ginfo = (SimWifiP2pInfo) intent.getSerializableExtra(
SimWifiP2pBroadcast.EXTRA_GROUP_INFO);
ginfo.print();
Toast.makeText(mActivity, "Network membership changed",
Toast.LENGTH_SHORT).show();
} else if (SimWifiP2pBroadcast.WIFI_P2P_GROUP_OWNERSHIP_CHANGED_ACTION.equals(action)) {
SimWifiP2pInfo ginfo = (SimWifiP2pInfo) intent.getSerializableExtra(
SimWifiP2pBroadcast.EXTRA_GROUP_INFO);
ginfo.print();
Toast.makeText(mActivity, "Group ownership changed",
Toast.LENGTH_SHORT).show();
}
}
}
| [
"[email protected]"
] | |
b6b38dd554a39efe77669d3eb152fa49f7d61756 | 9cec80ea40e9ed8cb9720a111dd4a6806c0efb8e | /backend/src/main/java/com/github/marcelomachadoxd/dsvendas/DsvendasApplication.java | b33dfe5a1924aa0cd0f3cb4b0fc9141e883d1d4b | [] | no_license | MarceloMachadoxD/DashboardVendas | ed96abe0ed35b1764bbc2667e4e2175b627c2177 | f6969b16ddbd417ee2f5b3f9fb00d89266d5b210 | refs/heads/main | 2023-04-24T11:29:51.820216 | 2021-05-08T17:11:47 | 2021-05-08T17:11:47 | 364,081,484 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 333 | java | package com.github.marcelomachadoxd.dsvendas;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DsvendasApplication {
public static void main(String[] args) {
SpringApplication.run(DsvendasApplication.class, args);
}
}
| [
"[email protected]"
] | |
d9b74389d01eaae61fdf74eb3ca67dbad10c0b1c | ba7ac99921d48d8cd49c54ac54f67654c2796450 | /Project51 Package/Project51 Server/src/ethos/model/npcs/animations/BlockAnimation.java | c0e35aa61c955072a2525c477fd9a8ecec84b679 | [] | no_license | JacobAYoung/server | ee1052b1423942036b6c7c77f33a2109e91ce502 | fd04421a6c16ce75f66556c8aeca1016a6318125 | refs/heads/master | 2022-11-22T22:44:10.417014 | 2020-07-03T02:02:06 | 2020-07-03T02:02:06 | 275,973,896 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 10,267 | java | package ethos.model.npcs.animations;
import ethos.Server;
import ethos.model.npcs.bosses.skotizo.Skotizo;
public class BlockAnimation {
public static int handleEmote(int i) {
switch (Server.npcHandler.getNPCs()[i].npcType) {
case 1739:
case 1740:
case 1741:
case 1742:
return -1;
case 8609:/* Hydra */
return -1;
case 8195://Bryophyta
return 7550;
case 7542: // Tekton legzone
return 7489;
case 7531://vespula
return 7450;
case 7562://muttadile
return 7420;
case 1127://giant scarab
return 5457;
case 3473://the inadequacy
return 6321;
case 7539://vespine soilder
return 7460;
case 8356://Nylocas Vasilia
return 7988;
case 7860://Porazdir
return 7838;
case 7859://darwen
return 7846;
case 7858://Justiciar Zachariah
return 7962;
//case 8342://Nylocas Ischyros
//return 8006;
case 7402://superior spectre
case 7403:
return 4651;
case 7390:
case 7391:
return 7546;
//Inferno Npcs
case 7691:
return 7575;
case 7692:
return 7579;
case 7693:
return 7585;
case 7694:
return 7585;
case 7695:
return 7585;
case 7696:
return 7585;
case 7697:
return 7598;
case 7699:
return 7609;
case 7700:
return 7591;
case 7702:
return 7607;
case 7706:
return 7565;
case 7707:
return 7568;
case 7708:
return 2869;
// case 7573:
// return 7196;
case 7563:
return 7421;
case Skotizo.SKOTIZO_ID:
return 4676;
case 7585:
case Skotizo.REANIMATED_DEMON:
return 65;
case 7604: // Skeletal mystic
case 7605: // Skeletal mystic
case 7606: // Skeletal mystic
return 5489;
case 2085:
return 4671;
case 7544: // Tekton
return 7489;
case 5916:
return 4523;
case 5890:
return 5755;
case 955:
case 957:
case 959:
return 6232;
case 7144:
case 7145:
case 7146:
return 7228;
case 458:
return 2777;
case 3544:
return 276;
case 1267:
return 2020;
case 2064:
return 1012;
case 2067:
return 6792;
case 2593:
return 6538;
case 963:
return 6232;
case 8030:
case 8031:
return 89;
case 965:
return 6237;
case 5862:
return 4489;
case 465: // Skeletal wyverns
return 2983;
case 6766: // Lizardman shaman
case 6768:
case 6914:
case 6915:
case 6916:
case 6917:
case 6918:
case 6919:
return 7194;
case 6618: // Crazy Archaeologist
case 6619:
return 424;
case 6615: // Scorpia
case 6616:
case 6617:
return 6255;
case 2527: // Ghosts
return 5541;
case 2528:
case 2529:
case 2530:
return 5533;
// case 6611:
// return 5489;
case 6462: // Zombies
case 6465:
return 5574;
case 6367: // Evil chicken
return 2299;
case 6369: // Agrith-na-na
return 3500;
case 6370: // Flambeed
return 1751;
case 6372: // Dessourt
return 3505;
case 6373:
case 6374:
case 6375:
case 6376:
case 6377:
case 6378:
return 1340;
case 437:
case 7277: // Jelly
case 7400:
case 7399:
case 411: // Kurask
case 7405:
case 3209: // Cave Horror
case 7401:
return 4235;
case 70:
return 5489;
case 419: // Cockatrice
case 7393:
return -1;
case 101:
return 6183;
case 3835:
return 6232;
case 2037:
return 5489;
case 5529:
return 5783;
case 5219:
case 5218:
return 5096;
case 5235:
return 5395;
case 10127:
return 13170;
case 10057:
return 10818;
case 5904:
return 6330;
case 5779:
return 3311;
case 5903:
return 6346;
case 9463:
case 9465:
case 9467:
return 12792;
case 6624:
return 7413;
case 6649:
return 7469;
case 6646:
return 7462;
case 3836:
return 6237;
case 4005: // Dark Beast
case 7409:
return 2732;
case 8133:
return 10058;
case 10141:
return 13601;
case 8349:
return 10923;
case 9947:
return 13771;
case 2215:
return 7019;
case 2216:
case 2217:
case 2218:
return 6155;
case 3162:
return 6978;
case 3163:
case 3164:
case 3165:
case 3169:
return 6952;
case 6576:
return 6944;
case 3130:
case 3131:
case 3132:
return 65;
case 6575:
return 6966;
case 6342:
return 5897;
/*
* case 2006: return 6375;
*/
case 2007:
return 7017;
case 2008:
return 4311;
case 6229:
case 6230:
case 6231:
case 6232:
case 6233:
case 6234:
case 6235:
case 6236:
case 6237:
case 6238:
case 6239:
case 6240:
case 6241:
case 6242:
case 6243:
case 6244:
case 6245:
case 6246:
return 6952;
case 6267:
return 360;
case 6268:
return 2933;
case 6269:
case 6270:
return 4651;
case 6271:
case 6272:
case 6273:
case 6274:
return 4322;
case 6275:
return 165;
case 6276:
case 6277:
case 6278:
return 4322;
case 6279:
case 6280:
return 6183;
case 6281:
return 6136;
case 6282:
return 6189;
case 6283:
return 6183;
case 6210:
return 6578;
case 6211:
return 170;
case 6212:
case 6213:
return 6538;
case 6215:
return 1550;
case 6216:
case 6217:
return 1581;
case 6218:
return 4301;
case 6258:
return 2561;
case 10775:
return 13154;
case 113:
return 129;
case 114:
return 360;
case 3058:
return 2937;
case 3061:
return 2961;
case 3063:
return 2937;
case 3065:
return 2720;
case 3066:
return 2926;
case 5935:// sand crabs
return 1313;
case 100:// rc
return 1313;
case 662:// goblins
return 6186;
case 118:
return 100;
case 2263:
return 2181;
case 2006:
case 1432:
case 752:
case 3064:
case 2026: // lesser
return 65;
case 3347:
case 3346:
return 3325;
case 1192:
return 1244;
case 3062:
return 2953;
case 3060:
return 2964;
case 2892: // Spinolyp
case 2894: // Spinolyp
case 2896: // Spinolyp
return 2869;
case 423: // Dust Devil
case 7404:
return 1555;
case 2054:
return 3148;
case 1354:
case 1341:
case 2455:// dagannoth
case 2454:
case 2456:
case 983:
case 984:
case 985:
case 986:
case 987:
case 988:
return 1340;
case 127:
return 186;
case 291:
return 100;
case 2267: // supreme
case 2266: // prime
case 2265: // rex
return 2852;
case 3452:// penance queen
return 5413;
case 2745:
return 2653;
case 2743:
return 2645;
case 1270:// metal dragon
case 273:
case 274:
case 6593:
return 89;
case 2598:
case 2599:
case 2600:
case 2610:
case 2601:
case 2602:
case 2603:
case 2606:// tzhaar-xil
case 2591:
case 2604:// tzhar-hur
return 2606;
case 3121:
return 2629;
case 66:
case 67:
case 168:
case 169:
case 162:
case 68:// gnomes
return 193;
case 160:
case 161:
return 194;
case 163:
case 164:
return 193;
case 438:
case 439:
case 440:
case 441:
case 442: // Tree spirit
case 443:
return 95;
case 391:
case 392:
case 393:
case 394:
case 395:// river troll
case 396:
return 285;
case 1153:
case 1154:
case 1155:
case 1156:
case 1157:
case 1158: // kalphite
return 1186;
case 1160: // kalphite
return 1179;
case 2734:
case 2627:// tzhaar
return 2622;
case 2630:
case 2629:
case 2736:
case 2738:
return 2626;
case 2631:
case 2632:
return 2629;
case 2741:
return 2635;
case 908:
return 129;
case 909:
return 147;
case 911:
return 65;
case 1459:// monkey guard
return 1403;
case 435: // pyrefiend
case 3406:
case 7394:
return 1581;
case 414:// banshee
case 7272:
return 1525;
case 448:
case 7388:
case 1649:
case 1650:
case 1651:
case 1652:
case 1653:
case 1654:
case 1655:
case 1656:
case 1657:// crawling hand
return 1591;
case 484:
case 7276:
case 1619:// bloodveld
case 7398:
case 7397:
return 1550;
case 446:
case 7396:
case 1644:
case 1645:
case 1646:
case 1647:// infernal mage
return 430;
case 11:// nechryael
case 7278:
return 1529;
case 7411:
return 7651;
case 1543:
case 1611:// gargoyle
case 7407:
return 1519;
case 415:// abyssal demon
case 7410:
return 1537;
case 1770:
case 1771:
case 1772:
case 1773:
case 2678:
case 2679:
case 1774:
case 1775:
case 1776:// goblins
return 312;
case 132: // monkey
return 221;
case 1030:
case 1031:
case 1032:
case 1033:
case 1034:
case 1035: // wolfman
return 6538;
case 1456:// monkey archer
return 1395;
case 108:// scorpion
case 1477:
return 247;
case 107:
case 144:
return 6255;
case 1125:// dad
return 285;
case 1096:
case 1097:
case 1098:
case 1942:
case 1101:// troll
case 1106:
return 285;
case 1095:
return 285;
case 123:
case 122:// hobgoblin
return 165;
case 135:// hellhound
case 142:
case 95:
return 6578;
case 1593:
case 152:
case 45:
case 1558: // wolf
case 1954:
return 76;
case 89:
return 6375;
case 133: // unicorns
return 290;
case 105:// bear
return 4921;
case 74:
case 75:
case 76:
return 5574;
case 73:
case 5399:
case 751: // zombie
case 77:
return 5574;
case 60:
case 64:
case 59:
case 61:
case 63:
case 3021:
case 2035: // spider
case 62:
case 1009:
return 5328;
case 2534:
case 85:
case 7258:
case 749:
case 104:
case 655:
case 491: // ghost
return 124;
case 1585:
case 2084: // giant
return 4671;
case 111:
return 4671;
case 2098:
case 2463:
case 116:
case 891:
case 7934:
return 4651;
case 239: // kbd
return 89;
case 264:// green dragon
case 268:
case 2919:
case 270:
case 742:
case 1589:
case 247:
case 52:
case 7273:
case 7274:
case 259:
case 7275:
return 89;
case 2889:
return 2860;
case 81: // cow
case 397:
return 5850;
case 708: // imp
case 7881:
return 170;
case 86:
case 87:
return 139;
case 47:// rat
return 2706;
case 2457:
return 2366;
case 128: // snake
case 1479:
return 276;
case 1017:
case 2693:
case 41: // chicken
return 55;
case 90:
case 91:
case 93: // skeleton
return 261;
case 1:
return 424;
default:
return -1;
}
}
}
| [
"[email protected]"
] | |
7159ee309e3dca8ac0538a3b05c791afee2e1798 | d60e287543a95a20350c2caeabafbec517cabe75 | /LACCPlus/Camel/1131_1.java | 7ab2476ac75a9b0c4c70d1f274c9733388246356 | [
"MIT"
] | permissive | sgholamian/log-aware-clone-detection | 242067df2db6fd056f8d917cfbc143615c558b2c | 9993cb081c420413c231d1807bfff342c39aa69a | refs/heads/main | 2023-07-20T09:32:19.757643 | 2021-08-27T15:02:50 | 2021-08-27T15:02:50 | 337,837,827 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 735 | java | //,temp,DatagramPacketEncoder.java,36,47,temp,DatagramPacketDelimiterDecoder.java,44,58
//,3
public class xxx {
@Override
protected void encode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
throws Exception {
if (msg.content() instanceof ByteBuf) {
ByteBuf payload = (ByteBuf) msg.content();
// Just wrap the message as DatagramPacket, need to make sure the message content is ByteBuf
DatagramPacket dp = new DatagramPacket(payload.retain(), msg.recipient());
out.add(dp);
} else {
LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
}
}
}; | [
"SHOSHIN\\[email protected]"
] | SHOSHIN\[email protected] |
ce84c17ef8e9fb95c1404c3bb36c95270522c0e8 | 5d9449f147b9127cd670a32ec2e5eaf96c9c9d93 | /src/main/java/dev/spring/boot/simple/model/Musica.java | 535e97efc769d1a92d911828a17e1bfe9ffcf9ca | [] | no_license | gabrielnascimentost/simpleApp_JavaSpringBoot | 848e18ac1708725f29ab3faf966ea8c59de38eea | f1ef665aeedcf1fe5ea7aa0ce9753e68e3467c43 | refs/heads/master | 2020-05-31T18:26:28.339811 | 2019-06-09T21:08:08 | 2019-06-09T21:08:08 | 190,434,546 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,167 | java | package dev.spring.boot.simple.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import org.hibernate.validator.constraints.Range;
/**
* Musica
*/
@Entity
@Table(name = "musicas")
public class Musica {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@NotBlank
@Size(min = 2, max = 50)
@Column(nullable = false, length = 50)
private String titulo;
@NotBlank
@Size(min = 2, max = 50)
@Column(nullable = false, length = 50)
private String banda;
@Range(min = 0, max = 10)
@Column(nullable = false)
private int nota;
@ManyToOne
@JoinColumn(name = "id_playlist_fk")
private Playlist playlist;
/**
* @return the banda
*/
public String getBanda() {
return banda;
}
/**
* @return the id
*/
public long getId() {
return id;
}
/**
* @return the nota
*/
public int getNota() {
return nota;
}
/**
* @return the playlist
*/
public Playlist getPlaylist() {
return playlist;
}
/**
* @return the titulo
*/
public String getTitulo() {
return titulo;
}
/**
* @param banda the banda to set
*/
public void setBanda(String banda) {
this.banda = banda;
}
/**
* @param id the id to set
*/
public void setId(long id) {
this.id = id;
}
/**
* @param nota the nota to set
*/
public void setNota(int nota) {
this.nota = nota;
}
/**
* @param playlist the playlist to set
*/
public void setPlaylist(Playlist playlist) {
this.playlist = playlist;
}
/**
* @param titulo the titulo to set
*/
public void setTitulo(String titulo) {
this.titulo = titulo;
}
} | [
"[email protected]"
] | |
fb3cb383de71d531548fb79d56840be154d583d2 | 63a0115c33c91c023966b26a08f4411384feca2c | /components/configuration-mgt/org.wso2.carbon.identity.configuration.mgt.endpoint/src/gen/java/org/wso2/carbon/identity/configuration/mgt/endpoint/dto/ResourceDTO.java | cc735c156810e4706ef209134f890a0047dc42ea | [
"Apache-2.0"
] | permissive | Kavindu-Dodan/carbon-identity-framework-1 | cd4579c0930d9bfbf0d46c5f683cf1cd87590af3 | a0856a7fccdf18821f6accc21ec021707ce1e8f3 | refs/heads/master | 2020-04-18T11:02:46.384062 | 2019-01-24T14:23:27 | 2019-01-24T14:23:27 | 167,487,009 | 0 | 0 | Apache-2.0 | 2019-01-25T04:53:58 | 2019-01-25T04:53:57 | null | UTF-8 | Java | false | false | 4,010 | java | /*
* Copyright (c) 2018, WSO2 Inc. (http://www.wso2.org) 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.wso2.carbon.identity.configuration.mgt.endpoint.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.ArrayList;
import java.util.List;
import javax.validation.constraints.NotNull;
@ApiModel(description = "")
public class ResourceDTO {
@NotNull
private String resourceId = null;
private String tenantDomain = null;
@NotNull
private String resourceName = null;
@NotNull
private String resourceType = null;
@NotNull
private String lastModified = null;
private List<AttributeDTO> attributes = new ArrayList<AttributeDTO>();
private List<ResourceFileDTO> files = new ArrayList<ResourceFileDTO>();
/**
**/
@ApiModelProperty(required = true, value = "")
@JsonProperty("resourceId")
public String getResourceId() {
return resourceId;
}
public void setResourceId(String resourceId) {
this.resourceId = resourceId;
}
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("tenantDomain")
public String getTenantDomain() {
return tenantDomain;
}
public void setTenantDomain(String tenantDomain) {
this.tenantDomain = tenantDomain;
}
/**
**/
@ApiModelProperty(required = true, value = "")
@JsonProperty("resourceName")
public String getResourceName() {
return resourceName;
}
public void setResourceName(String resourceName) {
this.resourceName = resourceName;
}
/**
**/
@ApiModelProperty(required = true, value = "")
@JsonProperty("resourceType")
public String getResourceType() {
return resourceType;
}
public void setResourceType(String resourceType) {
this.resourceType = resourceType;
}
/**
**/
@ApiModelProperty(required = true, value = "")
@JsonProperty("lastModified")
public String getLastModified() {
return lastModified;
}
public void setLastModified(String lastModified) {
this.lastModified = lastModified;
}
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("attributes")
public List<AttributeDTO> getAttributes() {
return attributes;
}
public void setAttributes(List<AttributeDTO> attributes) {
this.attributes = attributes;
}
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("files")
public List<ResourceFileDTO> getFiles() {
return files;
}
public void setFiles(List<ResourceFileDTO> files) {
this.files = files;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ResourceDTO {\n");
sb.append(" resourceId: ").append(resourceId).append("\n");
sb.append(" tenantDomain: ").append(tenantDomain).append("\n");
sb.append(" resourceName: ").append(resourceName).append("\n");
sb.append(" resourceType: ").append(resourceType).append("\n");
sb.append(" lastModified: ").append(lastModified).append("\n");
sb.append(" attributes: ").append(attributes).append("\n");
sb.append(" files: ").append(files).append("\n");
sb.append("}\n");
return sb.toString();
}
}
| [
"[email protected]"
] | |
0483dda333e783938333ead58fb869a45ee64dc5 | 90fdae2f1e82b8d3010ae9d46a5782cf86bbebf2 | /src/de/bl4ckskull666/bungeehelp/commands/Help.java | 97d1f63b58ac6d8c64a78f27296fba55da44da9b | [] | no_license | Bl4ckSkull666/BungeeHelp | dce34941d479ef2d3d07fb3e177132950108e7a2 | acd0aabd160fe085a3b128ce5950fd2f2dd42d48 | refs/heads/master | 2023-02-28T14:33:40.179670 | 2021-02-06T09:07:59 | 2021-02-06T09:07:59 | 60,637,336 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,038 | 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 de.bl4ckskull666.bungeehelp.commands;
import de.bl4ckskull666.bungeehelp.BH;
import de.bl4ckskull666.bungeehelp.LanguageManager;
import de.bl4ckskull666.bungeehelp.utils.Numbers;
import de.bl4ckskull666.mu1ti1ingu41.utils.Utils;
import java.util.HashMap;
import java.util.logging.Level;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.ProxyServer;
import net.md_5.bungee.api.chat.ClickEvent;
import net.md_5.bungee.api.chat.HoverEvent;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.chat.hover.content.Text;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.api.plugin.Command;
import org.bukkit.configuration.file.FileConfiguration;
/**
*
* @author Bl4ckSkull666
*/
public class Help extends Command {
public Help(String cmd, String perm) {
super(cmd, perm);
}
@Override
public void execute(CommandSender s, String[] a) {
if(!(s instanceof ProxiedPlayer))
return;
ProxyServer.getInstance().getScheduler().runAsync(BH.getPlugin(), new runCommand((ProxiedPlayer)s, a));
}
private class runCommand implements Runnable {
private final ProxiedPlayer _p;
private final String[] _a;
public runCommand(ProxiedPlayer p, String[] a) {
_p = p;
_a = a;
}
@Override
public void run() {
HashMap<String, String> sr = new HashMap<>();
FileConfiguration fc = LanguageManager.getLanguageConfiguration(_p);
if(fc == null) {
LanguageManager.sendMessage(_p, "internal-error", "We are Sorry, it's take a internal error. Please try again.", sr);
return;
}
String section = "help.global";
String server = _p.getServer().getInfo().getName().toLowerCase();
if(fc.isConfigurationSection("help." + server))
section = "help." + server;
String ssection = "index";
int page = 1;
if(_a.length > 0) {
for(String arg: _a) {
if(Numbers.isNumeric(arg)) {
page = Integer.parseInt(arg);
} else if(fc.isConfigurationSection(section + "." + arg)) {
ssection = arg;
}
}
}
if(!fc.isConfigurationSection(section + "." + ssection)) {
LanguageManager.sendMessage(_p, "unknow-section", "We are Sorry, but we can't find the given menu.", sr);
return;
}
int pages = 0;
for(String k: fc.getConfigurationSection(section + "." + ssection).getKeys(false)) {
if(Numbers.isNumeric(k))
pages++;
}
if(!fc.isList(section + "." + ssection + "." + String.valueOf(page)) && !fc.isConfigurationSection(section + "." + ssection + "." + String.valueOf(page))) {
if(!fc.isList(section + "." + ssection + ".1")) {
LanguageManager.sendMessage(_p, "no-page-found", "Can't find the giveb Page. View you Page 1.", sr);
page = 1;
} else {
LanguageManager.sendMessage(_p, "internal-error", "We are Sorry, it's take a internal error. Please try again.", sr);
return;
}
}
LanguageManager.sendMessage(_p, "header", "&e=============== &6Help Menu &e===============", sr);
if(fc.isList(section + "." + ssection + "." + String.valueOf(page))) {
for(String line: fc.getStringList(section + "." + ssection + "." + String.valueOf(page)))
_p.sendMessage(LanguageManager.convertString(setColor(line, _p)));
} else if(fc.isConfigurationSection(section + "." + ssection + "." + String.valueOf(page))) {
for(String k: fc.getConfigurationSection(section + "." + ssection + "." + String.valueOf(page)).getKeys(false)) {
String path = section + "." + ssection + "." + String.valueOf(page) + "." + k;
if(fc.isConfigurationSection(path) && fc.isString(path + ".message")) {
TextComponent msg = new TextComponent(setColor(fc.getString(path + ".message"), _p));
if(fc.isString(path + ".hover-text")) {
msg.setHoverEvent(
new HoverEvent(
Utils.isHoverAction("show_" + fc.getString(path + ".hover-type", "text"))?HoverEvent.Action.valueOf(("show_" + fc.getString(path + ".hover-type", "text")).toUpperCase()):HoverEvent.Action.SHOW_TEXT,
new Text(setColor(fc.getString(path + ".hover-text"), _p))
)
);
}
if(fc.isString(path + ".click-text")) {
msg.setClickEvent(
new ClickEvent(
Utils.isClickAction(fc.getString(path + ".click-type", "open_url"))?ClickEvent.Action.valueOf(fc.getString(path + ".click-type", "open_url").toUpperCase()):ClickEvent.Action.OPEN_URL,
setColor(fc.getString(path + ".click-text"), _p)
)
);
}
_p.sendMessage(msg);
} else if(fc.isString(path)) {
TextComponent msg = new TextComponent(setColor(fc.getString(path), _p));
_p.sendMessage(msg);
} else {
BH.getPlugin().getLogger().log(Level.INFO, "Missing Help path: " + path);
}
}
} else {
BH.getPlugin().getLogger().log(Level.INFO, "Wrong configuration of: " + section + "." + ssection + "." + String.valueOf(page));
return;
}
if(pages > 1) {
sr.put("%cur%", String.valueOf(page));
sr.put("%max%", String.valueOf(pages));
LanguageManager.sendMessage(_p, "page", "Page %cur% of %max% pages.", sr);
}
LanguageManager.sendMessage(_p, "footer", "&e=============== &6Help Menu &e===============", sr);
}
}
private String setColor(String str, ProxiedPlayer p) {
return ChatColor.translateAlternateColorCodes('&', str.replace("%name%", p.getName()).replace("%uuid%", p.getUniqueId().toString()).replace("%displayname%", p.getDisplayName()));
}
}
| [
"Bl4ckSkull666@Bl4ckSkull666PC"
] | Bl4ckSkull666@Bl4ckSkull666PC |
f639c90c3d93a08b53703117a23f6824df0d715c | c055229590992cc9707b085214b514174cc774ab | /src/edu/umn/cs/melt/copper/legacy/compiletime/srcbuilders/enginebuilders/RegexInfo.java | c0092f6ffde0967b6041acaa48ff533d725baa71 | [] | no_license | massimo-zaniboni/copper | edf3445e84e2a585aacffc0b53abe78506b43cc7 | fb57a789abaee336a11445dcd9d8b03042a8a989 | refs/heads/develop | 2021-01-18T16:04:23.229202 | 2016-05-01T22:07:41 | 2016-05-01T22:07:41 | 57,056,717 | 0 | 0 | null | 2016-04-25T16:10:55 | 2016-04-25T16:10:54 | null | UTF-8 | Java | false | false | 801 | java | package edu.umn.cs.melt.copper.legacy.compiletime.srcbuilders.enginebuilders;
import edu.umn.cs.melt.copper.legacy.compiletime.abstractsyntax.regex.ParsedRegex;
/**
* Holds information about a terminal symbol for the generator.
* @author August Schwerdfeger <<a href="mailto:[email protected]">[email protected]</a>>
*
*/
public class RegexInfo
{
private ParsedRegex regex;
private String semanticAction;
public RegexInfo(ParsedRegex regex, String semanticAction)
throws IndexOutOfBoundsException
{
this.regex = regex;
this.semanticAction = semanticAction;
}
/**
* @return Returns the regex.
*/
public ParsedRegex getRegex()
{
return regex;
}
/**
* @return Returns the semanticAction.
*/
public String getSemanticAction()
{
return semanticAction;
}
}
| [
"[email protected]"
] | |
0cc3a0d261de8aeda5a0e28c27b05aea13ca9e81 | eb1a96bbc163bb9a51246da4edc96477195b4823 | /src/main/java/filefinder/FileFinder.java | 2bbb481ca0802ed805dc7befb1d1500d18ea71ab | [] | no_license | JKleinRot/NedapUniversity_WirelessSoftwareMedium | df6ea4a8a32fa05bf5080e947af56bfaefc3f1ca | 56bf694fa3c3fc9f4f14f9269da0fa115fb0ba38 | refs/heads/master | 2020-03-09T11:34:51.479950 | 2018-04-19T09:36:01 | 2018-04-19T09:36:01 | 128,765,090 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 324 | java | package filefinder;
import java.net.DatagramPacket;
import packet.Packet;
public interface FileFinder {
/**
* Finds the files and directories in the directory.
*
* @param receivedPacket
* The received packet
* @return the packet to send
*/
public Packet find(DatagramPacket receivedPacket);
}
| [
"[email protected]"
] | |
7255e2bd458c8839d64ad419dac4fcd4504400a3 | 6495764044e972fab588161f1f19d7eb8a1327bb | /tools/java/org.hl7.fhir.instance/src/org/hl7/fhir/instance/model/api/IBaseElement.java | 95d0797308d82f0e9596d723b190154b223f905c | [
"BSD-3-Clause"
] | permissive | intervention-engine/fhir-golang-generator | 884a3522bee2ae0d69809a8f254c4c6dfbf6b459 | 6011e2b77b34cbb8b9d460a58fc6549c1d3e404d | refs/heads/master | 2020-02-26T14:38:31.250540 | 2016-10-07T15:23:23 | 2016-10-07T15:23:23 | 37,591,200 | 12 | 5 | null | 2017-04-04T17:49:09 | 2015-06-17T11:35:06 | HTML | UTF-8 | Java | false | false | 791 | java | package org.hl7.fhir.instance.model.api;
/*
* #%L
* HAPI FHIR - Core Library
* %%
* Copyright (C) 2014 - 2015 University Health Network
* %%
* 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.
* #L%
*/
public interface IBaseElement {
IBaseElement setId(String theValue);
}
| [
"jamesagnew@2f0db536-2c49-4257-a3fa-e771ed206c19"
] | jamesagnew@2f0db536-2c49-4257-a3fa-e771ed206c19 |
f6467ea24f577607c22caf18d48934e7fb2c24b8 | 41c748b27923d735154a24b4b87e4eea4d6b256a | /src/main/java/nl/ruben/postplein/SwaggerConfig.java | 9392dceeaa27394fd3c63d1a9c2dc89e47718aa1 | [] | no_license | t-tomaat/postplein | 9ed23cb7a5a266b4f4dfae7160041616f74cbce0 | 674f3f4ef80c2e49432fc46e1028159171d6a1c8 | refs/heads/master | 2023-04-04T05:01:53.799871 | 2021-04-27T18:58:44 | 2021-04-27T18:58:44 | 362,102,838 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,173 | java | package nl.ruben.postplein;
import java.util.ArrayList;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
public static final Contact CONTACT = new Contact("Tommy Tomaat", "https://github.com/t-tomaat",
"[email protected]");
private static final ApiInfo API_INFO = new ApiInfo("Users and posts", "Api Documentation", "1.0", "urn:tos",
CONTACT, "Apache 2.0", "http://www.apache.org/licenses/LICENSE-2.0", new ArrayList<>());
@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(API_INFO)
.select()
.apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build();
}
}
| [
"[email protected]"
] | |
7cd550fb873399beec4f40d20f059be379377bb1 | 29de0ca1f77ca063012b57b05c3bddbda8c40b39 | /DataStructure/Array/src/Medium/SetMatrixToZeroes.java | 7980a5008ff0a1eeea8fc1c421cea3c83aa12a0e | [] | no_license | sdaftari/DataStructureProblems | 55dfc8a6b66810da7bcafaf4cad20bfe13300951 | 1ac5f317dfa93edbdc9ac07f1ae002fe6e7f402d | refs/heads/master | 2020-05-09T20:18:09.372771 | 2019-05-15T17:38:32 | 2019-05-15T17:38:32 | 181,395,791 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,404 | java | //Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.
//
//Example 1:
//
//Input:
//[
// [1,1,1],
// [1,0,1],
// [1,1,1]
//]
//Output:
//[
// [1,0,1],
// [0,0,0],
// [1,0,1]
//]
package Medium;
public class SetMatrixToZeroes {
public static void main(String[] args) {
SetMatrixToZeroes obj = new SetMatrixToZeroes();
//int[][] nums = new int[][] {{1,1,1}, {1,0,1}, {1,1,1}};
int[][] nums = new int[][] {{1}, {0}};
obj.setZeroes(nums);
}
public void setZeroes(int[][] matrix) {
int col0 = 1, rows = matrix.length, cols = matrix[0].length;
for (int i = 0; i < rows; i++)
{
// if the first element in any row is 0, set col0 = 0
if (matrix[i][0] == 0)
col0 = 0;
// From first col, if any element is 0, make first element of that row and col = 0
for (int j = 1; j < cols; j++)
{
if (matrix[i][j] == 0)
matrix[i][0] = matrix[0][j] = 0;
}
}
for (int i = rows - 1; i >= 0; i--)
{
for (int j = cols - 1; j >= 1; j--)
if (matrix[i][0] == 0 || matrix[0][j] == 0)
matrix[i][j] = 0;
// Do this for upper rows
if (col0 == 0)
matrix[i][0] = 0;
}
}
}
| [
"[email protected]"
] | |
476dbac682943738be2a76f93187540ef07d34cc | 5708946209791ef273c59fe9156ce483e0c17fd7 | /src/main/java/org/marketdesignresearch/mechlib/outcomerules/ccg/constraintgeneration/ConstraintGenerator.java | 541a7639cc5477afcc3916eeb9017b342a8d4590 | [] | no_license | danhlephuoc/mechlib | cb3c3bc34b340cce7e7bc85a018f41bde3f8ad94 | 97713d744fa0def407c137cfd7f2b2bdd9cbaff1 | refs/heads/master | 2022-10-17T21:39:19.320721 | 2020-04-01T13:31:44 | 2020-04-01T13:31:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 413 | java | package org.marketdesignresearch.mechlib.outcomerules.ccg.constraintgeneration;
import org.marketdesignresearch.mechlib.core.Allocation;
import org.marketdesignresearch.mechlib.core.Outcome;
public interface ConstraintGenerator {
/**
*
* @param blockingCoalition
* @return the ids of the added constraints
*/
void addConstraint(Allocation blockingCoalition, Outcome priorResult);
}
| [
"[email protected]"
] | |
6a5680cb61902625c415c9218e49149e1e9d3232 | b3077792f987aacf38f56d6aae70cc4740105b3f | /MyScheduleService/src/vo/Note.java | b2907c1b936b2b3854748fb1116b07dfeff496cb | [] | no_license | byesoft/MyScheduleManager | 387c4b4564b74d2375f78b8c3fa001ad5b231e9c | f1edfbafbfd10a4795d6f29fc0bd5e0e702ed973 | refs/heads/master | 2021-01-22T00:29:23.135161 | 2015-06-23T05:58:49 | 2015-06-23T05:58:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,245 | java | package vo;
public class Note implements java.io.Serializable{
private static final long serialVersionUID = -5120486695962913889L;
private int _id = 0;
private String note_text = "";
private String create_time = "2014-4-23 19:00";
private int user_id = 0;
private String backup_time = "2014-4-23 19:00";
//get方法
public int get_id() {
return _id;
}
public void set_id(int _id) {
this._id = _id;
}
public String getNote_text() {
return note_text;
}
public void setNote_text(String note_text) {
this.note_text = note_text;
}
public String getCreate_time() {
return create_time;
}
public void setCreate_time(String create_time) {
this.create_time = create_time;
}
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public String getBackup_time() {
return backup_time;
}
public void setBackup_time(String backup_time) {
this.backup_time = backup_time;
}
public Note(int _id, String note_text, String create_time, int user_id,
String backup_time) {
super();
this._id = _id;
this.note_text = note_text;
this.create_time = create_time;
this.user_id = user_id;
this.backup_time = backup_time;
}
public Note() {
}
}
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.